Пример #1
0
        private void RunTest(RuleModel rule)
        {
            Logger._customAction = ExcuteRecord;
            var spider = new Spider(null, rule);

            spider.TestRule();
        }
Пример #2
0
        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)));
        }
Пример #3
0
        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));
            }
        }
Пример #4
0
        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);
        }
Пример #5
0
        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);
        }
Пример #6
0
        public async Task <IActionResult> CreateNewRule([FromBody] RuleModel ruleModel)
        {
            RuleDTO ruleDTO          = _mapper.Map <RuleDTO>(ruleModel);
            var     operationDetails = await _ruleService.CreateRule(ruleDTO);

            return(Ok(operationDetails));
        }
Пример #7
0
        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);
        }
Пример #8
0
            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);
            }
Пример #9
0
        //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);
            }
        }
Пример #10
0
        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;
            }
        }
Пример #11
0
 private void AppendOrderName(RuleModel rule, StringBuilder destination)
 {
     if (rule.IsOrderAppended)
     {
         destination.Append($"_order-{rule.MatchesCount}");
     }
 }
Пример #12
0
        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();
        }
Пример #13
0
        public JsonResult SaveExpression(ExpressionViewModel expression)
        {
            int newId = RuleModel.SaveExpression(expression);

            return(Json(new { id = newId }));
            //return PartialView("ViewRules");
        }
Пример #14
0
        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));
        }
Пример #15
0
        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);
        }
Пример #16
0
        /// <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);
        }
Пример #18
0
        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);
        }
    }
Пример #19
0
        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);
        }
Пример #20
0
        private async Task <RuleModel> GetRuleAndFunctionInfo(string dataConnector, int ruleId)
        {
            RuleManagement rules = new RuleManagement(_azureConnectionString);
            RuleModel      rule  = await rules.GetRuleAndFunction(dataConnector, ruleId);

            return(rule);
        }
Пример #21
0
        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;
            }
        }
Пример #22
0
        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);
        }
Пример #23
0
        private string GetValidRuleDescription(object loanValue, RuleModel ruleTreeStackItem)
        {
            string ruleDescription =
                $"Valid rule: {ruleTreeStackItem.Parameter} = {loanValue} for rule: {ruleTreeStackItem.Parameter} {ruleTreeStackItem.Operator} {ruleTreeStackItem.ValueToCompeare}.";

            return(ruleDescription);
        }
Пример #24
0
        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);
        }
Пример #25
0
        /// <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);
                    }
                }
            }
        }
Пример #26
0
        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);
        }
Пример #27
0
        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);
        }
Пример #28
0
        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);
        }
Пример #29
0
 // 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);
 }
Пример #30
0
        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);
        }
Пример #31
0
        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;
        }
Пример #32
0
        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;
        }
Пример #33
0
 public Rule()
 {
     DataContext = this;
     _selectedRule = new RuleModel();
 }
Пример #34
0
 private void Remove()
 {
     Device.RuleCollection.Remove(_selectedRule);
     SelectedRule = Device.RuleCollection.FirstOrDefault();
 }
Пример #35
0
 private void AddNew()
 {
     var newRule = new RuleModel() {};
     Device.RuleCollection.Add(newRule);
     SelectedRule = newRule;
     IsEditMode = true;
 }
Пример #36
0
 private void AddOutMessageQueue(RuleModel rule)
 {
     Thread.Sleep(rule.Interval);
     AccessFormMarshal("AppendToMonitorOutput", rule.OutMessage);
 }