public void Update(RuleViewModel Vm)
{
var data = _mapper.Map <Rule>(Vm);
_ruleRepository.Update(data);
SaveChanges();
}
public EditLockWindowViewModel(Window window, RuleViewModel existing = null)
{
this.existing = existing;
this.window = window;
Result = WindowResult.Cancelled;
}
public async Task <ActionResult> SaveModify(RuleViewModel model)
{
using (RuleServiceClient client = new RuleServiceClient())
{
MethodReturnResult <Rule> result = await client.GetAsync(model.Code);
if (result.Code == 0)
{
result.Data.FullPackageQty = model.FullPackageQty.Value;
result.Data.Name = model.Name;
result.Data.CalibrationCycle = model.CalibrationCycle;
result.Data.CalibrationType = model.CalibrationType;
result.Data.FixCycle = model.FixCycle;
result.Data.MaxPower = model.MaxPower;
result.Data.MinPower = model.MinPower;
result.Data.PowerDegree = model.PowerDegree;
result.Data.PowersetCode = model.PowersetCode.ToUpper();
result.Data.Description = model.Description;
result.Data.IsUsed = model.IsUsed;
result.Data.Editor = User.Identity.Name;
result.Data.EditTime = DateTime.Now;
MethodReturnResult rst = await client.ModifyAsync(result.Data);
if (rst.Code == 0)
{
rst.Message = string.Format(ZPVMResources.StringResource.Rule_SaveModify_Success
, model.Code);
}
return(Json(rst));
}
return(Json(result));
}
}
//
// POST: /ZPVM/Rule/Save
public async Task <ActionResult> Save(RuleViewModel model)
{
using (RuleServiceClient client = new RuleServiceClient())
{
Rule obj = new Rule()
{
Key = model.Code,
Name = model.Name.ToUpper(),
CalibrationCycle = model.CalibrationCycle,
CalibrationType = model.CalibrationType,
FixCycle = model.FixCycle,
MaxPower = model.MaxPower,
MinPower = model.MinPower,
PowerDegree = model.PowerDegree,
PowersetCode = model.PowersetCode.ToUpper(),
Description = model.Description,
IsUsed = model.IsUsed,
FullPackageQty = model.FullPackageQty.Value,
Editor = User.Identity.Name,
EditTime = DateTime.Now,
CreateTime = DateTime.Now,
Creator = User.Identity.Name
};
MethodReturnResult rst = await client.AddAsync(obj);
if (rst.Code == 0)
{
rst.Message = string.Format(ZPVMResources.StringResource.Rule_Save_Success
, obj.Key);
}
return(Json(rst));
}
}
public void Should_parse_contains_rule()
{
// arrange
var ruleViewModel = new RuleViewModel
{
Id = Guid.Parse("C61308F9-AB25-4123-9084-BCDA14F2540F"),
RuleDefinition = "Title Contains TESCO AND TESCO",
GroupName = "Some Group",
RuleName = "Some rule name"
};
//act
var result = Sut.Parse(ruleViewModel);
//assert
result.Should().BeEquivalentTo(new ParsedRule
{
Id = Guid.Parse("C61308F9-AB25-4123-9084-BCDA14F2540F"),
BankTransactionTypeId = null,
Column = "Title",
IsColumnInExtensions = false,
RuleType = RuleType.Contains,
Value = "TESCO AND TESCO",
GroupName = "Some Group",
RuleName = "Some rule name"
});
}
public RulePage()
{
InitializeComponent();
RuleViewModel ruleViewModel = new RuleViewModel();
DataContext = ruleViewModel;
}
public ActionContainerViewModel(ActionContainer model, RuleViewModel ruleViewModel, IAutomationService automationService,IAutomationDao automationDao)
{
Model = model;
_ruleViewModel = ruleViewModel;
_automationService = automationService;
_automationDao = automationDao;
}
public Rule Add(RuleViewModel Vm)
{
var entity = _mapper.Map <Rule>(Vm);
_ruleRepository.Add(entity);
SaveChanges();
return(entity);
}
internal CourseRuleViewModel GetCourseByCategory(string category, int StudentID)
{
Student student = entities.Students.Find(StudentID);
if (student == null)
{
return(new CourseRuleViewModel());
}
//student those record selected...
string[] studentCourseSelected = (from selectedCourse in entities.StudentCourseMappings where (selectedCourse.StudentID == student.StudentID) select selectedCourse.CourseCode).ToArray();
var categoryRecord = (from map in entities.Courses where (studentCourseSelected.Contains(map.CousreCode)) select map).FirstOrDefault();
// List<Cours> allCoursesWithCategory = (from map in entities.Courses where (map.Category == category.Category) select map).ToList();
List <CourseViewModel> allCoursesWithCategory = (from map in entities.Courses
where (map.Category == category)
select new CourseViewModel
{
CourseID = map.CourseID,
Capicity = map.Capicity,
Category = map.Category,
CousreCode = map.CousreCode,
CourseName = map.CourseName,
}).ToList();
List <CourseViewModel> selectedCourses = (from map in entities.Courses
where (studentCourseSelected.Contains(map.CousreCode))
select new CourseViewModel
{
CourseID = map.CourseID,
Capicity = map.Capicity,
Category = map.Category,
CousreCode = map.CousreCode,
CourseName = map.CourseName,
}).ToList();
foreach (CourseViewModel item in allCoursesWithCategory)
{
var rec = (from ss in selectedCourses where ss.CousreCode == item.CousreCode select ss.CourseID).ToList();
if (rec.Count > 0)
{
item.IsSelected = true;
}
}
RulesRepository rulesRepository = new RulesRepository();
RuleViewModel ruleViewModel = rulesRepository.GetRuleDetailsByCategory(category);
CourseRuleViewModel courseRuleViewModel = new CourseRuleViewModel();
courseRuleViewModel.CourseList = allCoursesWithCategory;
courseRuleViewModel.Rule = ruleViewModel;
return(courseRuleViewModel);
}
public override void SetModels(RuleViewModel rule, ThenDelimitHttp then = null)
{
base.SetModels(rule, then);
if (!IsSaved)
{
SaveCommand.Execute(this);
}
}
public override void SetModels(RuleViewModel rule, WhenIsDelimited when = null)
{
base.SetModels(rule, when);
if (!IsSaved)
{
SaveCommand.Execute(this);
}
}
public override void SetModels(RuleViewModel rule, ThenSkipProcessing then = null)
{
base.SetModels(rule, then);
if (!IsSaved)
{
SaveCommand.Execute(this);
}
}
public PartialViewResult CreateRules(int NodeId, string updateTargetId)
{
var rm = new RuleViewModel()
{
VariantID = NodeId
};
ViewBag.UpdateTargetId = updateTargetId;
return(PartialView(rm));
}
public RuleViewModel BuildNew(Rule rule)
{
var ruleViewModel = new RuleViewModel()
{
Id = rule.Id,
Name = rule.Name
};
return(ruleViewModel);
}
private static string CreateBrowseValue(RuleViewModel r)
{
var actionsBrowseValue = string.Join(string.Empty, r.Actions.Select(CreateBrowseValue));
var triggersBrowseValue = string.Join(string.Empty, r.Triggers.Select(CreateBrowseValue));
var conditionsBrowseValue = string.Join(string.Empty, r.Conditions.Select(CreateBrowseValue));
var tagsBrowseValue = r.Tags != null?string.Join(string.Empty, r.Tags) : string.Empty;
return
($"{r.Uid}{r.Name}{r.Description}{actionsBrowseValue}{triggersBrowseValue}{conditionsBrowseValue}{tagsBrowseValue}");
}
public RuleViewModel GetRuleDetailsByCategory(string Category)
{
RuleViewModel rulesViewModels = (from rule in entities.Rules
select new RuleViewModel
{
Category = rule.Category,
Min = rule.Min,
Max = rule.Max
}).Where(x => x.Category == Category).FirstOrDefault();
return(rulesViewModels);
}
public RuleViewer(ITestCase testCase, MainWindow mainWin)
{
InitializeComponent();
this.testCase = testCase;
MainWin = mainWin;
testCase.generate();
ruleTree = new RuleTreeControl(this);
ruleTreeContainer.Content = ruleTree;
docTreeViewControl = ruleTree.docTreeViewer;
ViewModel = new RuleViewModel(this, testCase);
ruleList.ViewModel = ViewModel;
newRuleButtonList.View = this;
newRuleButtonList.ViewModel = ViewModel;
}
public long UpdateRule(RuleViewModel UpdateRuleVm)
{
var rule = _ruleMain.GetRule(UpdateRuleVm.Id).Result;
rule.RuleTypeId = UpdateRuleVm.RuleTypeId;
rule.RuleDesc = UpdateRuleVm.RuleDesc;
rule.TimeSpanMinutes = UpdateRuleVm.TimeSpanMinutes;
rule.MeasurementAmount = UpdateRuleVm.MeasurementAmount;
rule.FraudScore = UpdateRuleVm.FraudScore;
rule.TransactionTypeId = UpdateRuleVm.TransactionTypeId;
rule.ActiveDate = UpdateRuleVm.ActiveDate;
rule.InactiveDate = UpdateRuleVm.InactiveDate;
return(_ruleMain.UpdateRule(rule).Result);
}
public void Should_return_null_if_invalid_rule()
{
// arrange
var ruleViewModel = new RuleViewModel
{
BankTransactionTypeId = Guid.NewGuid(),
RuleDefinition = "Extensions.Location Contains "
};
//act
var result = Sut.Parse(ruleViewModel.AsList());
//assert
result.Should().BeEmpty();
}
public long AddRule(RuleViewModel NewRuleVm)
{
var newRule = new Rule
{
RuleTypeId = NewRuleVm.RuleTypeId,
RuleDesc = NewRuleVm.RuleDesc,
TimeSpanMinutes = NewRuleVm.TimeSpanMinutes,
MeasurementAmount = NewRuleVm.MeasurementAmount,
FraudScore = NewRuleVm.FraudScore,
TransactionTypeId = NewRuleVm.TransactionTypeId,
ActiveDate = NewRuleVm.ActiveDate,
InactiveDate = NewRuleVm.InactiveDate
};
return(_ruleMain.AddRule(newRule).Result);
}
public async Task <IActionResult> Index(RuleViewModel model)
{
if (ModelState.IsValid)
{
await ruleRepository.AddRules(model.Rules);
await monthlyAllowanceRuleRepository.AddMonthlyAllowanceRules(model.Allowances);
TempData["StatusMessage"] = "Changes have been saved successfully.";
}
else
{
TempData["StatusMessage"] = "Error: Some fields are invalid!";
}
return(View(model));
}
public async Task <IActionResult> Edit(string jobId, string id)
{
RuleViewModel mapped;
if (string.IsNullOrEmpty(id))
{
mapped = new RuleViewModel();
}
else
{
var rule = await transmissionAppApi().ApiRulesByIdGetAsync(id, jobId);
mapped = mapper.Map <RuleViewModel>(rule);
}
mapped.JobId = jobId;
return(View(mapped));
}
public async Task <IActionResult> Edit(string jobId, string id, RuleViewModel viewModel)
{
if (ModelState.IsValid)
{
var client = transmissionAppApi();
var rule = mapper.Map <Api.Client.Models.RuleInModel>(viewModel);
if (String.IsNullOrEmpty(viewModel.Id))
{
await client.ApiRulesPostAsync(jobId, rule);
}
else
{
await client.ApiRulesByIdPutAsync(id, jobId, rule);
}
return(RedirectToAction("Edit", "Job", new { id = jobId }));
}
return(View(viewModel));
}
public static Rule Create(RuleViewModel ruleViewModel)
{
return(new Rule
{
Triggers = ruleViewModel.Triggers?.FromViewModels(),
Conditions = ruleViewModel.Conditions?.FromViewModels(),
Actions = ruleViewModel.Actions?.FromViewModels(),
Configuration = ruleViewModel.Configuration,
ConfigDescriptions = ruleViewModel.ConfigDescriptions?.FromViewModels(),
TemplateUid = ruleViewModel.TemplateUid,
Uid = ruleViewModel.Uid,
Name = ruleViewModel.Name,
Tags = ruleViewModel.Tags?.FromViewModels(),
Visibility = ruleViewModel.Visibility,
Description = ruleViewModel.Description,
Enabled = ruleViewModel.Enabled,
Status = ruleViewModel.Status?.FromViewModel()
});
}
public void Initilize()
{
var local = CommonDataManager.GetLocalCase(base.LocalID);
if (local.Pattern != Models.Enums.PatternTypeEnum.None)
{
this._patternType = local.Pattern;
this.RaisePropertyChanged(() => PatternName);
this.HasPattern = true;
}
this.ClassVM = CacheManager.Instance.UnityContainer.Resolve <ClassViewModel>();
this.CourseVM = CacheManager.Instance.UnityContainer.Resolve <CourseViewModel>();
this.RuleVM = CacheManager.Instance.UnityContainer.Resolve <RuleViewModel>();
this.StudentVM = CacheManager.Instance.UnityContainer.Resolve <StudentViewModel>();
this.TagVM = CacheManager.Instance.UnityContainer.Resolve <TagViewModel>();
this.TeacherVM = CacheManager.Instance.UnityContainer.Resolve <TeacherViewModel>();
this.TimeVM = CacheManager.Instance.UnityContainer.Resolve <TimeViewModel>();
}
public List <RuleViewModel> GetAllRule()
{
List <RuleViewModel> result = new List <RuleViewModel>();
List <RuleValueViewModel> rvvm = new List <RuleValueViewModel>();
List <RuleKey> rules = unitOfWork.Repository <RuleKey>().GetAll().ToList();
List <Rule> values = unitOfWork.Repository <Rule>().GetAll().Where(r => r.IsDisable == false).ToList();
foreach (var rule in rules)
{
foreach (var value in values)
{
if (value.KeyId == rule.Id)
{
var addValue = new RuleValueViewModel()
{
Id = value.Id,
KeyId = (int)value.KeyId,
IsCaseSensitive = value.Value.Contains("·case_sensitive·"),
Value = value.Value.Replace("·case_sensitive·", ""),
CreateDate = (DateTime)value.CreateDate,
ActivateDate = (DateTime)value.ActivateDate,
ValueGroup = value.ValueGroup,
IsUse = (bool)value.IsUse
};
rvvm.Add(addValue);
}
}
var addResult = new RuleViewModel()
{
Id = rule.Id,
Code = rule.Code,
Name = rule.Name,
Value = rvvm,
GroupType = (int)rule.GroupType,
GroupTypeEnum = (RuleEnum)rule.GroupType
};
result.Add(addResult);
rvvm = new List <RuleValueViewModel>();
}
return(result);
}
public CourseRuleViewModel GetCourseByCategory(string Category)
{
RulesRepository rulesRepository = new RulesRepository();
RuleViewModel ruleViewModel = rulesRepository.GetRuleDetailsByCategory(Category);
List <CourseViewModel> courseViewModels = (from course in entities.Courses
select new CourseViewModel
{
CourseID = course.CourseID,
CousreCode = course.CousreCode,
CourseName = course.CourseName,
Category = course.Category,
Capicity = course.Capicity,
}).Where(x => x.Category == Category).ToList();
CourseRuleViewModel courseRuleViewModel = new CourseRuleViewModel();
courseRuleViewModel.CourseList = courseViewModels;
courseRuleViewModel.Rule = ruleViewModel;
return(courseRuleViewModel);
}
public ActionResult Create([Bind(Include = "Id,MassType,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday,I,II,III,IV,V,VI,VII,VIII,IX,X,XI,XII,Week1,Week2,Week3,Week4,Week5,WeekLast,CycleType,DateBegin,DateEnd,Hour,DateShift,Repeat,ChurchId,CycleId,HolidayId,Comment,AdditionalMasses")] RuleViewModel viewModel)
{
if (ModelState.IsValid)
{
viewModel.AdditionalMasses.Add(new Envelope {
Hour = viewModel.Hour, MassType = viewModel.MassType
});
//viewModel.AdditionalMasses = viewModel.AdditionalMasses.DistinctBy(e => e.Hour).ToList();
viewModel.AdditionalMasses.Sort((e1, e2) => { return(TimeSpan.Compare(e1.Hour, e2.Hour)); });
foreach (var h in viewModel.AdditionalMasses)
{
Rule rule = viewModel.ToRule();
rule.Hour = h.Hour;
rule.MassType = h.MassType;
db.Rules.Add(rule);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(viewModel));
}
public void Should_parse_contains_rule_and_extension_column()
{
// arrange
var ruleViewModel = new RuleViewModel
{
BankTransactionTypeId = Guid.NewGuid(),
RuleDefinition = "Extensions.Location Contains TESCO"
};
//act
var result = Sut.Parse(ruleViewModel);
//assert
result.Should().BeEquivalentTo(new ParsedRule
{
BankTransactionTypeId = ruleViewModel.BankTransactionTypeId,
Column = "Location",
IsColumnInExtensions = true,
RuleType = RuleType.Contains,
Value = "TESCO",
});
}
//
// GET: /ZPVM/Rule/Modify
public async Task <ActionResult> Modify(string code)
{
RuleViewModel viewModel = new RuleViewModel();
using (RuleServiceClient client = new RuleServiceClient())
{
MethodReturnResult <Rule> result = await client.GetAsync(code);
if (result.Code == 0)
{
viewModel = new RuleViewModel()
{
Code = result.Data.Key,
Name = result.Data.Name,
CalibrationType = result.Data.CalibrationType,
PowersetCode = result.Data.PowersetCode,
PowerDegree = result.Data.PowerDegree,
MinPower = result.Data.MinPower,
MaxPower = result.Data.MaxPower,
FixCycle = result.Data.FixCycle,
CalibrationCycle = result.Data.CalibrationCycle,
Description = result.Data.Description,
IsUsed = result.Data.IsUsed,
FullPackageQty = result.Data.FullPackageQty,
CreateTime = result.Data.CreateTime,
Creator = result.Data.Creator,
Editor = result.Data.Editor,
EditTime = result.Data.EditTime
};
return(PartialView("_ModifyPartial", viewModel));
}
else
{
ModelState.AddModelError("", result.Message);
}
}
return(PartialView("_ModifyPartial"));
}
public ParsedRule Parse(RuleViewModel rule)
{
var splittedString = rule.RuleDefinition.Split(" ", StringSplitOptions.RemoveEmptyEntries);
if (splittedString.Length < 3)
{
logger.LogWarning($"Invalid rule {rule.RuleDefinition}");
return(null);
}
var parsedRule = new ParsedRule
{
Id = rule.Id,
BankTransactionTypeId = rule.BankTransactionTypeId,
Column = splittedString[0].Replace("Extensions.", "").Trim(),
IsColumnInExtensions = splittedString[0].StartsWith("Extensions."),
RuleType = Enum.Parse <RuleType>(splittedString[1].Trim()),
Value = string.Join(" ", splittedString.Skip(2)),
GroupName = rule.GroupName,
RuleName = rule.RuleName
};
return(parsedRule);
}
public void ReindexRulesTest()
{
var f = new StateViewModel { Name = "false" };
var t = new StateViewModel { Name = "true" };
var validConditionStates = new List<StateViewModel>(new[] { t, f });
var conditions = new List<ConditionViewModel>();
for (int i = 0; i < 3; i++)
conditions.Add(new ConditionViewModel
{
Name = string.Format("Condition {0}", i),
});
var actualConditionStates = new Dictionary<ConditionViewModel, List<StateViewModel>>
{
{ conditions[0], new StateViewModel[] { t, t, t, t, f, f, f, f }.ToList() },
{ conditions[1], new StateViewModel[] { t, t, f, f, t, t, f, f }.ToList() },
{ conditions[2], new StateViewModel[] { t, f, t, f, t, f, t, f }.ToList() },
};
var ruleCount = actualConditionStates.First().Value.Count;
var expectedOrder = new List<RuleViewModel>();
for (int ruleIndex = 0; ruleIndex < ruleCount; ruleIndex++)
{
var conditionStates = new Dictionary<ConditionViewModel, StateViewModel>();
foreach (var pair in actualConditionStates)
conditionStates.Add(pair.Key, pair.Value[ruleIndex]);
RuleViewModel newRule = new RuleViewModel
{
Index = ruleIndex * 2,
ConditionStates = conditionStates,
};
DecisionTable.Rules.Add(newRule);
expectedOrder.Add(newRule);
}
var actual = DecisionTableViewModelUtils.Instance.ReindexRules(DecisionTable.Rules.Reverse<RuleViewModel>());
CollectionAssert.AreEqual(expectedOrder, actual);
for (int i = 0; i < actual.Count; i++)
Assert.AreEqual(i, actual[i].Index);
}
private bool CompareConditions(RuleViewModel ruleA, RuleViewModel ruleB)
{
foreach (var conditionPairA in ruleA.ConditionStates)
{
var curConditionId = conditionPairA.Key.EntityId;
var stateA = conditionPairA.Value;
var matchingPairB = ruleB.ConditionStates.First(cur => cur.Key.EntityId.Equals(curConditionId));
var stateB = matchingPairB.Value;
if (!stateA.EntityId.Equals(stateB.EntityId))
return false;
}
return true;
}
public ActionContainerViewModel(ActionContainer model, RuleViewModel ruleViewModel)
{
Model = model;
_ruleViewModel = ruleViewModel;
}
