private void RunTest(RuleModel rule) { Logger._customAction = ExcuteRecord; var spider = new Spider(null, rule); spider.TestRule(); }
public IActionResult CreateRule(RuleType ruleType, string regexSender, string regexText) { try { // ReSharper disable once ReturnValueOfPureMethodIsNotUsed if (!string.IsNullOrEmpty(regexSender)) { Regex.Match("test", regexSender); } // ReSharper disable once ReturnValueOfPureMethodIsNotUsed if (!string.IsNullOrEmpty(regexText)) { Regex.Match("test", regexText); } } catch { return(RedirectToAction(nameof(SmsRules))); } var rule = new RuleModel(ruleType, regexSender, regexText); _objectRepository.Add(rule); return(RedirectToAction(nameof(SmsRules))); }
public async Task <IActionResult> Alter([FromBody] RuleModel ruleModel, [FromServices] AlterRuleService service) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { var rule = this.mapper.Map <Rule>(ruleModel); var result = await service.Handle(rule); if (result.IsSuccess) { return(Ok(mapper.Map <RuleModel>(rule))); } else { return(BadRequest(result.Errors)); } } catch (FormatException ex) { return(BadRequest("Error parsing data " + ex.Message)); } }
public static PredictionResult PredictDepthUsingIDW(QcRuleSetup qcSetup, DbUtilities dbConn) { double? depth = null; PredictionResult result = new PredictionResult { Status = "Failed" }; DataTable nb = RuleMethodUtilities.GetNeighbors(dbConn, qcSetup); if (nb != null) { depth = RuleMethodUtilities.CalculateDepthUsingIdw(nb, qcSetup); } if (depth != null) { RuleModel rule = JsonConvert.DeserializeObject <RuleModel>(qcSetup.RuleObject); JObject dataObject = JObject.Parse(qcSetup.DataObject); dataObject[rule.DataAttribute] = depth; string remark = dataObject["REMARK"] + $";{rule.DataAttribute} has been predicted by QCEngine;"; dataObject["REMARK"] = remark; result.DataObject = dataObject.ToString(); result.DataType = rule.DataType; result.SaveType = "Update"; result.IndexId = qcSetup.IndexId; result.Status = "Passed"; } return(result); }
public static PredictionResult PredictLogDepthAttributes(QcRuleSetup qcSetup, DbUtilities dbConn) { PredictionResult result = new PredictionResult { Status = "Failed" }; JObject dataObject = JObject.Parse(qcSetup.DataObject); RuleModel rule = JsonConvert.DeserializeObject <RuleModel>(qcSetup.RuleObject); string jsonLog = RuleMethodUtilities.GetLogCurveDepths(dbConn, qcSetup.DataObject); if (!string.IsNullOrEmpty(jsonLog)) { JObject logObject = JObject.Parse(jsonLog); string attribute = rule.DataAttribute; dataObject[attribute] = logObject[attribute]; string remark = dataObject["REMARK"] + $";{attribute} was calculated from curve array;"; dataObject["REMARK"] = remark; result.DataObject = dataObject.ToString(); result.DataType = rule.DataType; result.SaveType = "Update"; result.IndexId = qcSetup.IndexId; result.Status = "Passed"; } return(result); }
public async Task <IActionResult> CreateNewRule([FromBody] RuleModel ruleModel) { RuleDTO ruleDTO = _mapper.Map <RuleDTO>(ruleModel); var operationDetails = await _ruleService.CreateRule(ruleDTO); return(Ok(operationDetails)); }
public static RuleModel ToRuleModel(this ReportingDescriptor rule, string defaultRuleId) { RuleModel model; string ruleId = defaultRuleId; if (Guid.TryParse(ruleId, out Guid result) && !(string.IsNullOrEmpty(rule.Name))) { ruleId = rule.Name; } if (rule == null) { model = new RuleModel() { Id = ruleId, DefaultFailureLevel = FailureLevel.Warning }; } else { model = new RuleModel() { Id = ruleId, Name = rule.Name, Description = rule.FullDescription?.Text, DefaultFailureLevel = rule.DefaultConfiguration != null ? rule.DefaultConfiguration.Level : FailureLevel.Warning, // Default level HelpUri = rule.HelpUri?.IsAbsoluteUri == true ? rule.HelpUri.AbsoluteUri : null }; } return(model); }
public static RuleModel Parse(IEnumerable <string> input) { var model = new RuleModel(); foreach (var line in input) { var nullMatch = NullRuleParser.Match(line); if (nullMatch.Success) { model.AddNodeIfNotExists(nullMatch.Groups[1].Value); continue; } var match = RuleParser.Match(line); var from = match.Groups[1].Value.Trim(); var toChunk = match.Groups[2].Value; foreach (var part in toChunk.Split(", ")) { var chunkMatch = ToRuleParser.Match(part); var to = chunkMatch.Groups[2].Value.Trim(); var count = int.Parse(chunkMatch.Groups[1].Value); model.AddEdge(from, to, count); } } return(model); }
//send 3 params 1,1..... private bool CheckRuleValid(object loanValueToCompare, RuleModel ruleTreeStackItem, List <int> ignoreRules) { if (ignoreRules != null && ignoreRules.Contains(ruleTreeStackItem.Id))//approve by manager { return(true); } var parameterType = rulesParameterTypes[ruleTreeStackItem.Parameter]; switch (parameterType) { case "int": Expression <Func <int, bool> > intRuleExpression = GetRuleExpression(ruleTreeStackItem.Parameter, ruleTreeStackItem.Operator, Convert.ToInt32(ruleTreeStackItem.ValueToCompeare)); return(intRuleExpression.Compile()((int)loanValueToCompare)); case "bool": Expression <Func <bool, bool> > boolRuleExpression = GetRuleExpression(ruleTreeStackItem.Parameter, ruleTreeStackItem.Operator, Convert.ToBoolean(ruleTreeStackItem.ValueToCompeare)); return(boolRuleExpression.Compile()((bool)loanValueToCompare)); case "string": Expression <Func <string, bool> > stringRuleExpression = GetRuleExpression(ruleTreeStackItem.Parameter, ruleTreeStackItem.Operator, Convert.ToString(ruleTreeStackItem.ValueToCompeare)); return(stringRuleExpression.Compile()((string)loanValueToCompare)); default: return(false); } }
public async Task CloseDataQC(string source, List <RuleFailures> ruleFailures) { try { ConnectParameters connector = await GetConnector(source); RuleManagement rm = new RuleManagement(_azureConnectionString); string jsonRules = await rm.GetRules(source); List <RuleModel> rules = JsonConvert.DeserializeObject <List <RuleModel> >(jsonRules); ManageIndexTable idxTable = new ManageIndexTable(connector.ConnectionString); await idxTable.GetIndexQCFlagData(); foreach (var ruleFailure in ruleFailures) { RuleModel rule = rules.FirstOrDefault(o => o.Id == ruleFailure.RuleId); foreach (var failure in ruleFailure.Failures) { string qcString = idxTable.GetQCFlag(failure); qcString = qcString + rule.RuleKey + ";"; idxTable.SetQCFlag(failure, qcString); } } idxTable.SaveQCFlagDapper(); } catch (Exception ex) { Exception error = new Exception($"DataQc: Could not close and save qc flags, {ex}"); throw error; } }
private void AppendOrderName(RuleModel rule, StringBuilder destination) { if (rule.IsOrderAppended) { destination.Append($"_order-{rule.MatchesCount}"); } }
public async Task ExecutePrediction(PredictionParameters parms) { string accessJson = await _fileStorage.ReadFile("connectdefinition", "PPDMDataAccess.json"); _accessDefs = JsonConvert.DeserializeObject <List <DataAccessDef> >(accessJson); ConnectParameters connector = await GetConnector(parms.DataConnector); databaseConnectionString = connector.ConnectionString; _dbConn.OpenConnection(connector); string sourceConnector = GetSource(); if (parms.DataConnector == sourceConnector) { syncPredictions = true; } else { syncPredictions = false; } RuleManagement rules = new RuleManagement(_azureConnectionString); RuleModel rule = await rules.GetRuleAndFunction(parms.DataConnector, parms.PredictionId); manageIndexTable = new ManageIndexTable(_accessDefs, connector.ConnectionString, rule.DataType, rule.FailRule); manageIndexTable.InitQCFlags(false); await MakePredictions(rule, connector); _dbConn.CloseConnection(); manageIndexTable.SaveQCFlags(); }
public JsonResult SaveExpression(ExpressionViewModel expression) { int newId = RuleModel.SaveExpression(expression); return(Json(new { id = newId })); //return PartialView("ViewRules"); }
public async Task <IActionResult> Edit(int id, [Bind("ValidationID,Name,category,age,begin,end")] RuleModel ruleModel) { if (id != ruleModel.ValidationID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(ruleModel); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!RuleModelExists(ruleModel.ValidationID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(ruleModel)); }
public void AddRule(RuleModel model) { string sql = @"insert into Rules( Name ,RegValue ,ReplaceValue ,Desc CreateDate ) values ( @Name ,@RegValue ,@ReplaceValue ,@Desc ,@CreateDate )"; object[] sqlParams = new object[] { model.Name , model.RegValue , model.ReplaceValue , model.Desc , model.CreateDate.ToString("yyyy-MM-dd HH:mm:ss") }; SQLiteHelper.Instance.ExecuteNonQuery(sql, sqlParams); }
/// <summary> /// Generates the list of "RulesModel" for each issue /// </summary> /// <param name="xmlDocument">The xml document that has the list of data</param> private void GenerateRuleTreeList(XmlDocument xmlDocument) { var rules = xmlDocument.GetElementsByTagName("Rule"); foreach (XmlNode rule in rules) { var ruleModel = new RuleModel(xmlDocument.BaseURI) { TypeName = XmlNodeHelper.GetNodeAttributeValue(rule, "TypeName"), Category = XmlNodeHelper.GetNodeAttributeValue(rule, "Category"), CheckId = XmlNodeHelper.GetNodeAttributeValue(rule, "CheckId"), Name = rule["Name"]?.InnerText, Description = rule["Description"]?.InnerText, Resolution = new ResolutionModel { Name = XmlNodeHelper.GetNodeAttributeValue(rule["Resolution"], "Name"), Text = rule["Resolution"]?.InnerText }, Owner = rule["Owner"]?.InnerText, Url = rule["Url"]?.InnerText, MessageLevel = new MessageLevelModel { Certainty = Convert.ToInt32(XmlNodeHelper.GetNodeAttributeValue(rule["MessageLevel"], "Certainty") ?? "0"), Text = rule["MessageLevel"]?.InnerText } }; ruleModelList.Add(ruleModel); } }
public static RuleModel ToRuleModel(this ReportingDescriptor rule, string defaultRuleId) { RuleModel model; if (rule == null) { model = new RuleModel() { Id = defaultRuleId, DefaultFailureLevel = FailureLevel.Warning }; } else { model = new RuleModel() { Id = rule.Id, Name = rule.Name, Description = rule.FullDescription?.Text, DefaultFailureLevel = rule.DefaultConfiguration != null ? rule.DefaultConfiguration.Level : FailureLevel.Warning, // Default level HelpUri = rule.HelpUri?.IsAbsoluteUri == true ? rule.HelpUri.AbsoluteUri : null }; } return(model); }
private List <string> GetInfos(RuleModel rule) { if (rule == null) { return(null); } if (rule.IsDefault()) { return new List <string>() { rule.DefaultValue } } ; List <string> contents = this._contentExtract.ParseList(rule.XpathExtractModel); if (rule.IsFilter()) { return(rule.Filter(contents)); } return(contents); } }
private string ProcessQcRule(QcRuleSetup qcSetup, RuleModel rule) { string returnResult = "Passed"; var jsonString = JsonConvert.SerializeObject(qcSetup); var content = new StringContent(jsonString, Encoding.UTF8, "application/json"); try { using (HttpClient client = new HttpClient()) { using (HttpResponseMessage response = client.PostAsync(rule.RuleFunction, content).Result) { using (HttpContent respContent = response.Content) { var tr = respContent.ReadAsStringAsync().Result; var azureResponse = JsonConvert.DeserializeObject(tr); returnResult = azureResponse.ToString(); } } } } catch (Exception ex) { Exception error = new Exception("DataQcWithProgressBar: Problems with URL: ", ex); throw error; } return(returnResult); }
private async Task <RuleModel> GetRuleAndFunctionInfo(string dataConnector, int ruleId) { RuleManagement rules = new RuleManagement(_azureConnectionString); RuleModel rule = await rules.GetRuleAndFunction(dataConnector, ruleId); return(rule); }
public async Task <List <int> > ExecuteQcRule(DataQCParameters qcParms) { try { ConnectParameters connector = await GetConnector(qcParms.DataConnector); RuleModel rule = await GetRuleAndFunctionInfo(qcParms.DataConnector, qcParms.RuleId); string accessJson = await _fileStorage.ReadFile("connectdefinition", "PPDMDataAccess.json"); _accessDefs = JsonConvert.DeserializeObject <List <DataAccessDef> >(accessJson); DbUtilities dbConn = new DbUtilities(); dbConn.OpenConnection(connector); manageQCFlags = new ManageIndexTable(_accessDefs, connector.ConnectionString, rule.DataType); List <int> failedObjects = await QualityCheckDataType(dbConn, rule, connector); dbConn.CloseConnection(); return(failedObjects); } catch (Exception ex) { Exception error = new Exception($"DataQc: Could process rule {qcParms.RuleId}, {ex}"); throw error; } }
private bool CheckBranchRulesValid(RuleModel ruleRoot, RuleTreeNode checkedRulesRoot, CheckLoanValid message) { //depth tree scan using stack bool isBranchValid = true; Stack <RuleModel> rulesTreeStack = new Stack <RuleModel>(); Stack <RuleTreeNode> checkedRulesTreeStack = new Stack <RuleTreeNode>(); rulesTreeStack.Push(ruleRoot); checkedRulesTreeStack.Push(checkedRulesRoot); while (!(rulesTreeStack.Count == 0)) { var currentRuleToCheck = rulesTreeStack.Pop(); var currentCheckedRuleToUpdate = checkedRulesTreeStack.Pop(); for (int j = 0; j < currentRuleToCheck.ChildrenRules.Count; j++)//create stack of branch nodes { rulesTreeStack.Push(currentRuleToCheck.ChildrenRules[j]); checkedRulesTreeStack.Push(currentCheckedRuleToUpdate.ChildrenRules[j]); } var loanValueToCompare = message.LoanDetails.GetType().GetProperty(currentRuleToCheck.Parameter).GetValue(message.LoanDetails, null); bool isRuleValid = CheckRuleValid(loanValueToCompare, currentRuleToCheck, message.IgnoreRules); isBranchValid = isRuleValid ? isBranchValid : false; UpdateCheckedRulesTree(loanValueToCompare, currentCheckedRuleToUpdate, currentRuleToCheck, isRuleValid); if (currentRuleToCheck.ChildrenRules.Count == 0)//at end of branch { if (isBranchValid) { return(true); } isBranchValid = true; } } return(false); }
private string GetValidRuleDescription(object loanValue, RuleModel ruleTreeStackItem) { string ruleDescription = $"Valid rule: {ruleTreeStackItem.Parameter} = {loanValue} for rule: {ruleTreeStackItem.Parameter} {ruleTreeStackItem.Operator} {ruleTreeStackItem.ValueToCompeare}."; return(ruleDescription); }
public IList <RuleModel> GetRules() { var rules = new List <RuleModel>(); Assembly asm = Assembly.Load("SqlCop.Rules"); Type[] types = asm.GetTypes(); IEnumerable <Type> sqlRuleTypes = types.Where(s => s.BaseType == typeof(Rule)); foreach (Type type in sqlRuleTypes) { IEnumerable <CustomAttributeData> attributes = type.CustomAttributes.Where(a => a.AttributeType == typeof(RuleAttribute)); foreach (var ruleAttribute in attributes) { IList <CustomAttributeTypedArgument> args = ruleAttribute.ConstructorArguments; if (args.Count == 4) { var rule = new RuleModel() { Namespace = args[0].Value as string, Id = args[1].Value as string, Name = args[2].Value as string, Category = args[3].Value as string, RuleType = type }; rules.Add(rule); } } } return(rules); }
/// <summary> /// Legac code, isn't relevant. /// This function saves the rule into the database while keeping the last rule (the everything else rule) last. /// I desided that the user should be aware that the everything else should always be last. instead of making my life harder and checking if there even is /// </summary> /// <param name="rule"></param> public static void saveRuleLast(RuleModel rule) { var ruleList = Tagger.getRulesList(); var lastRule = ruleList[ruleList.Count - 1]; using (IDbConnection cnn = new SQLiteConnection(connectionStringTags)) { cnn.Execute("PRAGMA foreign_keys=ON"); cnn.Execute("DELETE FROM Rule where rowid = @RowId", lastRule); try { cnn.Execute("insert into Rule (Parameter,Operation,Constant,TagId) values (@Parameter,@Operation,@Constant,@TagId)", rule); cnn.Execute("insert into Rule (Parameter,Operation,Constant,TagId) values (@Parameter,@Operation,@Constant,@TagId)", lastRule); } catch (SQLiteException e) { if (e.Message.Contains("UNIQUE")) { MessageBox.Show("This Rule existis already. \n Can't add same rule for different Tag!", "Error", MessageBoxButton.OK, MessageBoxImage.Error); cnn.Execute("insert into Rule (Parameter,Operation,Constant,TagId) values (@Parameter,@Operation,@Constant,@TagId)", lastRule); } else { MessageBox.Show(e.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error); } } } }
private DbParameter[] ExecutionSelectRule(RuleModel DataPar) { string WebSit = WebPath + DataPar.RuleImage; DataPar.RuleImage = DataPar.RuleImage.Substring(DataPar.RuleImage.LastIndexOf('/') + 1); DbParameter[] sqliteparList = new DbParameter[8]; sqliteparList[0] = Db_Sqlite.CreateDbParameter("@UpdateTime", DataPar.UpdateTime); sqliteparList[1] = Db_Sqlite.CreateDbParameter("@ID", DataPar.RuleID); sqliteparList[2] = Db_Sqlite.CreateDbParameter("@Address", DataPar.RuleAddress); sqliteparList[3] = Db_Sqlite.CreateDbParameter("@Telephone", DataPar.RuleTelephone); sqliteparList[4] = Db_Sqlite.CreateDbParameter("@Internet", DataPar.RuleInternet); sqliteparList[5] = Db_Sqlite.CreateDbParameter("@Content", DataPar.RuleContent); sqliteparList[6] = Db_Sqlite.CreateDbParameter("@Bus", DataPar.RuleBus); sqliteparList[7] = Db_Sqlite.CreateDbParameter("@Image", DataPar.RuleImage); string SavePath = LoadPath + @"\Resources\" + DataPar.RuleImage; if (DataPar.RuleImage != null && DataPar.RuleImage != string.Empty) { try { DownLoad(WebSit, SavePath); } catch (Exception ex) { WriteLog("没有物业概况图片资源" + ex.Message.ToString()); } } return(sqliteparList); }
public static string Completeness(QcRuleSetup qcSetup, DataTable dt, List <DataAccessDef> accessDefs, IIndexDBAccess indexData) { string returnStatus = "Passed"; RuleModel rule = JsonConvert.DeserializeObject <RuleModel>(qcSetup.RuleObject); JObject dataObject = JObject.Parse(qcSetup.DataObject); JToken value = dataObject.GetValue(rule.DataAttribute); if (value == null) { //log.Warning($"Attribute is Null"); } else { string strValue = value.ToString(); if (string.IsNullOrWhiteSpace(strValue)) { returnStatus = "Failed"; } else { double number; bool canConvert = double.TryParse(strValue, out number); if (canConvert) { if (number == -99999) { returnStatus = "Failed"; } } } } return(returnStatus); }
public static string Consistency(QcRuleSetup qcSetup, DataTable dt, List <DataAccessDef> accessDefs, IIndexDBAccess indexData) { string returnStatus = "Passed"; RuleModel rule = JsonConvert.DeserializeObject <RuleModel>(qcSetup.RuleObject); JObject dataObject = JObject.Parse(qcSetup.DataObject); JToken value = dataObject.GetValue(rule.DataAttribute); string strValue = value.ToString(); if (Common.CompletenessCheck(strValue) == "Passed") { string dataType = rule.DataType; IndexModel index = Task.Run(() => indexData.GetIndex(qcSetup.IndexId, qcSetup.DataConnector)).GetAwaiter().GetResult(); if (index != null) { string query = " where " + index.DataKey; DataAccessDef dataAccessDef = accessDefs.First(x => x.DataType == dataType); string sql = dataAccessDef.Select + query; IADODataAccess consistencyConn = new ADODataAccess(); DataTable ct = consistencyConn.GetDataTable(sql, qcSetup.ConsistencyConnectorString); Dictionary <string, string> columnTypes = ct.GetColumnTypes(); if (ct.Rows.Count > 0) { string strRefValue = ct.Rows[0][rule.DataAttribute].ToString(); string valueType = columnTypes[rule.DataAttribute]; if (Common.CompletenessCheck(strRefValue) == "Passed") { returnStatus = RuleMethodUtilities.ConsistencyCheck(strValue, strRefValue, valueType); } } } } return(returnStatus); }
// ToDo: refine message public InvalidConfigurationUncheckedPlaceholdersException(RuleModel rule, IEnumerable <string> missingPlaceholders, PrimitiveValueSet brokenListItem) { this.RuleName = rule.Name; this.RuleSetID = rule.RuleSetID; this.MissingPlaceholders = missingPlaceholders.ToArray(); this.BrokenListItem = JsonConvert.SerializeObject(brokenListItem, Formatting.Indented); }
public static RuleModel ToRuleModel(this IRule rule, string defaultRuleId) { RuleModel model; if (rule == null) { model = new RuleModel() { Id = defaultRuleId, }; } else { model = new RuleModel() { Id = rule.Id, Name = rule.Name?.Text, Category = rule.GetCategory(), Description = rule.FullDescription?.Text, HelpUri = rule.HelpUri?.AbsoluteUri }; } return(model); }
public static WebSiteModel CreateModel(List<UrlModel> downloadUrls, RuleModel rule, Uri sourceAddress) { WebSiteModel model = new WebSiteModel(); model.DownloadUrls = downloadUrls; model.Rule = rule; model.SourceAddress = sourceAddress; return model; }
public static RuleModel CreateModel(string titleXPath, string articleXPath, string typeXPath, string recomendXPath , string summaryXPath, string imageXPath, string createdXPath) { RuleModel model = new RuleModel(); model.TitleXPath = titleXPath; model.ArticleXPath = articleXPath; model.TypeXPath = titleXPath; model.RecomendXPath = recomendXPath; model.SummaryXPath = summaryXPath; model.ImageXPath = imageXPath; model.CreatedXPath = createdXPath; return model; }
public Rule() { DataContext = this; _selectedRule = new RuleModel(); }
private void Remove() { Device.RuleCollection.Remove(_selectedRule); SelectedRule = Device.RuleCollection.FirstOrDefault(); }
private void AddNew() { var newRule = new RuleModel() {}; Device.RuleCollection.Add(newRule); SelectedRule = newRule; IsEditMode = true; }
private void AddOutMessageQueue(RuleModel rule) { Thread.Sleep(rule.Interval); AccessFormMarshal("AppendToMonitorOutput", rule.OutMessage); }