public ActionResult Edit(RulesModel model, Table table)
{
string result = "";
switch (table)
{
case Table.ApprovedRules:
result = rules.EditRule(model.ApprovedRule.RuleID, model.ApprovedRule.Question, model.ApprovedRule.Answer, User.Identity.Name, model.ApprovedRule.Lookup, Table.ApprovedRules);
break;
case Table.RejectedRules:
result = rules.EditRule(model.RejectedRule.RuleID, model.RejectedRule.Question, model.RejectedRule.Answer, User.Identity.Name, model.RejectedRule.Lookup, Table.RejectedRules);
break;
case Table.PendingRules:
result = rules.EditRule(model.PendingRule.RuleID, model.PendingRule.Question, model.PendingRule.Answer, User.Identity.Name, model.PendingRule.Lookup, Table.PendingRules);
break;
default:
System.Diagnostics.Debug.WriteLine("Unknown table");
break;
}
if (result == null)
{
return(RedirectToAction("RulesList"));
}
else
{
ViewBag.DuplicateError = result;
return(View(model));
}
}
public IActionResult Index(RulesModel ruleModel)
{
if (HttpContext.Session.Get("CustomerID") == null)
{
return(RedirectToAction("Index", "Login"));
}
return(View(GenerateRulesModel(ruleModel.curAccount)));
}
public async Task <RulesModel> ListRules(string wit)
{
string src = _appSettings.Value.SourceForRules;
var json = await _httpClient.GetStringAsync(src + "/rules." + wit.ToLower() + ".json");
RulesModel rules = JsonConvert.DeserializeObject <RulesModel>(json);
return(rules);
}
/// <summary>
/// Конвертирование модели правила в DTO для типа операции
/// </summary>
/// <param name="ruleToConvert">Объект модели правила</param>
/// <returns>DTO правила для типа операции</returns>
public RuleDto ConvertRuleModelToDTO(RulesModel ruleToConvert) => new RuleDto
{
RuleId = ruleToConvert.Id,
SourceAccount = ruleToConvert.SourceAccount,
DestinationAccount = ruleToConvert.DestinationAccount,
RuleOrderNumber = ruleToConvert.RuleOrderNumber,
Description = ruleToConvert.Description,
Formula = ruleToConvert.Formula,
DateFrom = ruleToConvert.DateFrom,
OperationTypeId = ruleToConvert.OperationTypeId
};
public RulesModel ListRules(string wit)
{
string src = _appSettings.Value.SourceForRules;
using (WebClient wc = new WebClient())
{
var json = wc.DownloadString(src + "/rules." + wit.ToLower() + ".json");
RulesModel rules = JsonConvert.DeserializeObject <RulesModel>(json);
return(rules);
}
}
public ActionResult Index([Bind(Include = "Question,Answer")] RulesModel model)
{
if (ModelState.IsValidField("Question"))
{
EFRules Rules = new EFRules();
model.Answer = Rules.GetAnswer(model.Question);
}
else
{
ViewBag.EmptyError = "The Question field cannot be empty.";
}
return(View(model));
}
/// <summary>
/// Add columns and create templates for them using variable's term.
/// </summary>
/// <param name="rules"></param>
/// <param name="inputVariables"></param>
/// <param name="ourputVariables"></param>
private void AddColumnsAndCreateItsCellTemplatesIntoDataGrid(RulesModel rules, ICollection <FuzzyVariableModel> inputVariables, ICollection <FuzzyVariableModel> ourputVariables)
{
foreach (var variable in inputVariables.Concat(ourputVariables))
{
var col = new DataGridViewComboBoxColumn // TODO: here could be call an interface method
{
Name = variable.Name,
DataSource = variable.Terms.Select(t => t.Name).ToList(),
ValueType = typeof(string)
};
this.dataGridViewRules.Columns.Add(col);
}
this.dataGridViewRules.Columns[inputVariables.Count - 1].DividerWidth = 3; // width = 3px
}
public string MarkovAlgorithm(List <RulesModel> rules, string cypher)
{
RulesModel rule = rules.FirstOrDefault(R => cypher.Contains(R.Source));
if (rule == null)
{
return(cypher);
}
cypher = cypher.Replace(rule.Source, rule.Replacement);
if (rule.IsTermination)
{
return(cypher);
}
return(MarkovAlgorithm(rules, cypher));
}
private void SetRulesToDataGrid(RulesModel rules)
{
if (rules.Rules.Any(r => r.Value.Count > this.dataGridViewRules.RowCount))
{
this.dataGridViewRules.Rows.Add(rules.Rules.Select(r => r.Value.Count).FirstOrDefault());
}
foreach (var ruleItem in rules.Rules) // dictionary <string, List<string>>
{
for (int i = 0; i < ruleItem.Value.Count; i++)
{
this.dataGridViewRules[ruleItem.Key, i].Value = ruleItem.Value[i];
}
}
}
public IActionResult Edit(RulesModel ruleModel)
{
if (HttpContext.Session.Get("CustomerID") == null)
{
return(RedirectToAction("Index", "Login"));
}
if (ruleModel.rules.startTrans < new DateTime(1900, 1, 1) ||
ruleModel.rules.startTrans > new DateTime(9999, 12, 31))
{
ModelState.AddModelError("startTrans", "The field Start date must be between 1/1/1900 and 12/31/9999.");
}
if (ruleModel.rules.endTrans < new DateTime(1900, 1, 1) ||
ruleModel.rules.endTrans > new DateTime(9999, 12, 31))
{
ModelState.AddModelError("endTrans", "The field End date must be between 1/1/1900 and 12/31/9999.");
}
if (ruleModel.rules.startTrans > ruleModel.rules.endTrans)
{
ModelState.AddModelError("startTrans", "The Start date must be before End date.");
}
Int32 customerID = (Int32)HttpContext.Session.GetInt32("CustomerID");
if (!ModelState.IsValid)
{
ruleModel.curAccount = ruleModel.rules.accountID;
ruleModel.accounts = DatabaseHandler.getAccounts(customerID);
return(View("Index", ruleModel));
}
if (ruleModel.rules.OutStateTrans == false && ruleModel.rules.rangeTrans == false &&
ruleModel.rules.catTrans == false && ruleModel.rules.greatTrans == false &&
ruleModel.rules.greatDepo == false && ruleModel.rules.greatWithdraw == false &&
ruleModel.rules.greatBal == false && ruleModel.rules.lessBal == false)
{
DatabaseHandler.deleteRules(customerID, ruleModel.rules.accountID);
}
else
{
DatabaseHandler.setRules(customerID, ruleModel.rules);
}
ViewBag.Success = true;
return(View("Index", GenerateRulesModel(ruleModel.rules.accountID)));
}
public async Task <RulesModel> ListRules(string wit)
{
string src = _appSettings.Value.SourceForRules;
// set baseUrl to current context if SourceForRule is a relative path, i.e, not starting with http
if (!src.ToLower().StartsWith("http"))
{
src = $"{_httpContextAccessor.HttpContext.Request.Scheme}://{_httpContextAccessor.HttpContext.Request.Host}/{src}";
}
var json = await _httpClient.GetStringAsync($"{src}/rules.{wit.ToLower()}.json");
RulesModel rules = JsonConvert.DeserializeObject <RulesModel>(json);
return(rules);
}
public RulesWizardDialog(RuleBlockModel ruleBlock)
{
InitializeComponent();
this.ruleBlock = ruleBlock;
if (this.ruleBlock.Rules == null)
{
rules = new RulesModel();
}
else
{
rules = this.ruleBlock.Rules;
}
this.AddColumnsAndCreateItsCellTemplatesIntoDataGrid(this.rules, this.ruleBlock.InputFuzzyVariables, this.ruleBlock.OutputFuzzyVariables);
this.SetRulesToDataGrid(this.rules);
}
public ActionResult Add([Bind(Include = "Question,Answer,Lookup")] RulesModel model)
{
if (ModelState.IsValid)
{
string result;
if ((result = rules.AddRule(model.Question, model.Answer, User.Identity.Name, User.Identity.Name, User.Identity.Name, model.Lookup, Table.PendingRules)) == null)
{
return(RedirectToAction("RulesList"));
}
else
{
ViewBag.DuplicateError = result;
return(View());
}
}
else
{
return(View());
}
}
private RulesModel GenerateRulesModel(int account = 0)
{
RulesModel rulesModel = new RulesModel();
Int32 customerID = (Int32)HttpContext.Session.GetInt32("CustomerID");
List <Int32> accountIDs = DatabaseHandler.getAccounts(customerID);
rulesModel.accounts = accountIDs;
if (accountIDs.Count > 0)
{
if (account > 0)
{
rulesModel.curAccount = account;
rulesModel.rules = DatabaseHandler.getRules(customerID, account);
}
else
{
rulesModel.curAccount = accountIDs[0];
rulesModel.rules = DatabaseHandler.getRules(customerID, accountIDs[0]);
}
}
return(rulesModel);
}
private void GetRulesFromDataGrid(RulesModel rules)
{
List <string> values = null;
for (int i = 0; i < this.dataGridViewRules.ColumnCount; i++)
{
values = new List <string>();
for (int j = 0; j < this.dataGridViewRules.RowCount - 1; j++)
{
values.Add(this.dataGridViewRules[i, j].Value?.ToString());
}
// rewrites values or creates new one.
if (this.rules.Rules.ContainsKey(this.dataGridViewRules.Columns[i].Name))
{
rules.Rules[this.dataGridViewRules.Columns[i].Name] = values;
}
else
{
rules.Rules.Add(this.dataGridViewRules.Columns[i].Name.ToString(), values);
}
}
}
public void HomeController_GetAnswer_AnswerNotFound()
{
// add and approve the rule
efrules.AddRule("Test Question?", "Test Answer", "User", "User", "User", null, Table.PendingRules);
efrules.ApproveRule("Test Question?", "User", "User", "User");
Assert.IsFalse(efrules.GetAnswerFromPending("Test Question?").Contains("Test Answer"));
// create the home controller and mock rules model
var controller = new HomeController();
var model = new RulesModel {
Question = "Not a Test Question?"
};
// get the answer
var result = controller.Index(model) as ViewResult;
var response = (RulesModel)result.ViewData.Model;
// answer is not found
Assert.AreEqual("Sorry, no result was found for that query", response.Answer);
// delete the rule
efrules.DeleteRule("Test Question?", Table.ApprovedRules);
}
public ActionResult Index()
{
RulesModel model = new RulesModel();
return(View(model));
}
/// <summary>
/// Initializes a new instance of the <see cref="RuleBlockModel"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="inputFuzzyVariables">The input fuzzy variables.</param>
/// <param name="outputFuzzyVariables">The output fuzzy variables.</param>
/// <param name="rules">The rules.</param>
public RuleBlockModel(string name, ObservableCollection <FuzzyVariableModel> inputFuzzyVariables, ObservableCollection <FuzzyVariableModel> outputFuzzyVariables, RulesModel rules)
{
this.Name = name;
this.InputFuzzyVariables = inputFuzzyVariables;
this.OutputFuzzyVariables = outputFuzzyVariables;
this.Rules = rules;
}
/// <summary> /// Изменение правил для типа операции /// </summary> /// <param name="rule">Правило с изменениями</param> public void UpdateRule(RulesModel rule) => _context.Rules.Update(rule);
/// <summary> /// Удаление правил для типа операций /// </summary> /// <param name="rules">Список правил</param> public void DeleteRule(RulesModel rule) => _context.Rules.Remove(rule);
public async Task <IActionResult> Post([FromBody] JObject payload)
{
PayloadViewModel vm = BuildPayloadViewModel(payload);
//make sure pat is not empty, if it is, pull from appsettings
vm.pat = _appSettings.Value.PersonalAccessToken;
//if the event type is something other the updated, then lets just return an ok
if (vm.eventType != "workitem.updated")
{
return(new OkResult());
}
// create our azure devops connection
Uri baseUri = new Uri("https://dev.azure.com/" + vm.organization);
VssCredentials clientCredentials = new VssCredentials(new VssBasicCredential("username", vm.pat));
VssConnection vssConnection = new VssConnection(baseUri, clientCredentials);
// load the work item posted
WorkItem workItem = await _workItemRepo.GetWorkItem(vssConnection, vm.workItemId);
// this should never happen, but if we can't load the work item from the id, then exit with error
if (workItem == null)
{
return(new StandardResponseObjectResult("Error loading workitem '" + vm.workItemId + "'", StatusCodes.Status500InternalServerError));
}
// get the related parent
WorkItemRelation parentRelation = workItem.Relations.Where <WorkItemRelation>(x => x.Rel.Equals("System.LinkTypes.Hierarchy-Reverse")).FirstOrDefault();
// if we don't have any parents to worry about, then just abort
if (parentRelation == null)
{
return(new OkResult());
}
Int32 parentId = _helper.GetWorkItemIdFromUrl(parentRelation.Url);
WorkItem parentWorkItem = await _workItemRepo.GetWorkItem(vssConnection, parentId);
if (parentWorkItem == null)
{
return(new StandardResponseObjectResult("Error loading parent work item '" + parentId.ToString() + "'", StatusCodes.Status500InternalServerError));
}
string parentState = parentWorkItem.Fields["System.State"] == null ? string.Empty : parentWorkItem.Fields["System.State"].ToString();
// load rules for updated work item
RulesModel rulesModel = _rulesRepo.ListRules(vm.workItemType);
//loop through each rule
foreach (var rule in rulesModel.Rules)
{
if (rule.IfChildState.Equals(vm.state))
{
if (!rule.AllChildren)
{
if (!rule.NotParentStates.Contains(parentState))
{
await _workItemRepo.UpdateWorkItemState(vssConnection, parentWorkItem, rule.SetParentStateTo);
return(new OkResult());
}
}
else
{
// get a list of all the child items to see if they are all closed or not
List <WorkItem> childWorkItems = await _workItemRepo.ListChildWorkItemsForParent(vssConnection, parentWorkItem);
// check to see if any of the child items are not closed, if so, we will get a count > 0
int count = childWorkItems.Where(x => !x.Fields["System.State"].ToString().Equals(rule.IfChildState)).ToList().Count;
if (count.Equals(0))
{
await _workItemRepo.UpdateWorkItemState(vssConnection, parentWorkItem, rule.SetParentStateTo);
}
return(new OkResult());
}
}
}
return(new StandardResponseObjectResult("success", StatusCodes.Status200OK));
}
/// <summary> /// Добавление правила к типу операции /// </summary> /// <param name="rule">Правило</param> /// <param name="ct">Токен отмены</param> /// <returns></returns> public async Task AddRule(RulesModel rule, CancellationToken ct) => await _context.Rules.AddAsync(rule, ct);
