public IActionResult Insert(int id)
{
var conditionVM = new ConditionVM();
conditionVM.VehicleId = id;
return(View(conditionVM));
}
public async Task <ApiResultVM <string> > Update(ConditionVM conditionVM, int id)
{
var checkValue = await GetById(id);
var vehicleId = await _vehicleService.GetById(conditionVM.VehicleId);
if (checkValue == null)
{
_dbContextDTO.Dispose();
return(new ApiErrorResultVM <string>("Condition doesn't exist"));
}
if (vehicleId == null)
{
_dbContextDTO.Dispose();
return(new ApiErrorResultVM <string>("Vehicle doesn't exist to update condition"));
}
if (conditionVM.Note == null)
{
conditionVM.Note = "Không";
}
var ConditionDTO = _mapper.Map <ConditionDTO>(conditionVM);
ConditionDTO.Id = id;
ConditionDTO.UpdateAt = DateTime.Now;
dbset.Update(ConditionDTO);
await _dbContextDTO.SaveChangesAsync();
return(new ApiSuccessResultVM <string>("Update Success"));
}
public async Task <IActionResult> UpdateAction(ConditionVM conditionVM)
{
if (ModelState.IsValid)
{
string token = HttpContext.Session.GetString("token_access");
if (conditionVM.file != null)
{
string image = await _conditionServiceApiClient.UploadImage(conditionVM.file, token);
conditionVM.ImagePath = image;
}
var result = await _conditionServiceApiClient.Update(conditionVM, token);
if (result.IsSuccessed == true)
{
TempData["SuccessResult"] = result.Entity;
return(Redirect("/vehicle/GetAllConditionById/" + conditionVM.VehicleId));
}
else
{
ModelState.AddModelError("", result.Message);
return(View("Update", conditionVM));
}
}
return(View("Update", conditionVM));
}
// POST: api/Conditions
public HttpResponseMessage InsertCondition(ConditionVM conditionVM)
{
var message = Request.CreateErrorResponse(HttpStatusCode.NotFound, "Not Found");
var result = iConditionService.Insert(conditionVM);
if (result)
{
message = Request.CreateResponse(HttpStatusCode.OK);
}
return(message);
}
// PUT: api/Conditions/5
public HttpResponseMessage UpdateCondition(int id, ConditionVM conditionVM)
{
var message = Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
var result = iConditionService.Update(id, conditionVM);
if (result)
{
message = Request.CreateResponse(HttpStatusCode.OK, conditionVM);
}
return(message);
}
public bool Update(int id, ConditionVM conditionVM)
{
if (string.IsNullOrWhiteSpace(conditionVM.Id.ToString()))
{
return(status);
}
else
{
return(iConditionRepository.Update(id, conditionVM));
}
}
public bool Insert(ConditionVM conditionVM)
{
if (string.IsNullOrWhiteSpace(conditionVM.Condition))
{
return(status);
}
else
{
return(iConditionRepository.Insert(conditionVM));
}
}
public async Task <ApiResultVM <string> > Update(ConditionVM conditionVM, string token)
{
var client = _httpClientFactory.CreateClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
client.BaseAddress = new Uri(_configuration["UrlApi"]);
conditionVM.file = null;
var response = await client.PutAsJsonAsync("/api/conditions/" + conditionVM.Id, conditionVM);
var body = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <ApiResultVM <string> >(body));
}
public bool Update(int id, ConditionVM conditionVM)
{
var get = Get(id);
if (get != null)
{
get.Update(id, conditionVM);
myContext.Entry(get).State = EntityState.Modified;
myContext.SaveChanges();
return(true);
}
else
{
return(false);
}
}
public void EvaluateConditionShould_ErrorIfNoAnswerSupplied()
{
//Arrange
var condition = new ConditionVM()
{
Logic = new LogicVM()
{
Answer = null
}
};
//Act + Assert
var ex = Assert.Throws <NullReferenceException>(() =>
DynamicContentHelpers.EvaluateCondition(condition, formContext));
ex.Message.Should().Contain("Object reference not set to an instance of an object");
}
public bool Insert(ConditionVM conditionVM)
{
var push = new Condition(conditionVM);
myContext.Conditions.Add(push);
var result = myContext.SaveChanges();
if (result > 0)
{
status = true;
}
else
{
return(status);
}
return(status);
}
public void EvaluateConditionShould_ErrorIfVariableSourceUnrecognised()
{
//Arrange
var condition = new ConditionVM()
{
Logic = new LogicVM()
{
Source = "not-a-source",
Answer = ""
}
};
//Act + Assert
var ex = Assert.Throws <ArgumentException>(() =>
DynamicContentHelpers.EvaluateCondition(condition, formContext));
ex.Message.Should().Contain("Unrecognised variable source type");
}
public void EvaluateConditionShould_ErrorIfVariableNotFound()
{
//Arrange
var condition = new ConditionVM()
{
Logic = new LogicVM()
{
Source = "formData",
Variable = "not-a-formData-id",
Answer = ""
}
};
//Act + Assert
var ex = Assert.Throws <Exception>(() => DynamicContentHelpers.EvaluateCondition(condition, formContext));
ex.Message.Should().Contain("Unable to resolve dynamic content variable");
}
public void EvaluateConditionShould_ErrorIf_OperatorIsGreaterOrLessThan_AndVariableOrAnswerCannotBeParsedToFloat(string variable, string Operator, string answer)
{
//Arrange
var condition = new ConditionVM()
{
Logic = new LogicVM()
{
Source = "answer",
Variable = variable,
Operator = Operator,
Answer = answer
}
};
//Act + Assert
var ex = Assert.Throws <ArgumentException>(() => DynamicContentHelpers.EvaluateCondition(condition, formContext));
ex.Message.Should().Contain("cannot be parsed to float");
}
public void EvaluateConditionShould_ErrorIfOperatorUnrecognised()
{
//Arrange
var condition = new ConditionVM()
{
Logic = new LogicVM()
{
Source = "answer",
Variable = "page1-question1",
Operator = "not-an-operator",
Answer = ""
}
};
//Act + Assert
var ex = Assert.Throws <ArgumentException>(() => DynamicContentHelpers.EvaluateCondition(condition, formContext));
ex.Message.Should().Contain("Unrecognised logic operator");
}
public void EvaluateConditionShould_ReturnFalse(string source, string variable, string Operator, string answer)
{
//Arrange
var condition = new ConditionVM()
{
Logic = new LogicVM()
{
Source = source,
Variable = variable,
Operator = Operator,
Answer = answer
}
};
//Act
var sut = DynamicContentHelpers.EvaluateCondition(condition, formContext);
//Assert
sut.Should().BeFalse();
}
public async Task <ApiResultVM <string> > Insert(ConditionVM conditionVM)
{
var vehicleId = await _vehicleService.GetById(conditionVM.VehicleId);
if (vehicleId == null)
{
_dbContextDTO.Dispose();
return(new ApiErrorResultVM <string>("Vehicle doesn't exist to insert condition"));
}
if (conditionVM.Note == null)
{
conditionVM.Note = "Không";
}
var ConditionDTO = _mapper.Map <ConditionDTO>(conditionVM);
ConditionDTO.CreateAt = DateTime.Now;
ConditionDTO.UpdateAt = DateTime.Now;
await dbset.AddAsync(ConditionDTO);
await _dbContextDTO.SaveChangesAsync();
return(new ApiSuccessResultVM <string>("Insert Success"));
}
public Conditions()
{
InitializeComponent();
conditionVM = new ConditionVM();
}
public IActionResult Update(ConditionVM conditionVM)
{
return(View(conditionVM));
}
public Condition(ConditionVM conditionVM)
{
this.Conditon = conditionVM.Condition;
}
public void Update(int id, ConditionVM conditionVM)
{
this.Conditon = conditionVM.Condition;
}
public async Task <IActionResult> Update(ConditionVM ConditionVM, int id)
{
var result = await _ConditionService.Update(ConditionVM, id);
return(Ok(result));
}
public async Task <IActionResult> Insert(ConditionVM ConditionVM)
{
var result = await _ConditionService.Insert(ConditionVM);
return(Ok(result));
}
/// <summary>
/// Evaluates a condition against source data in formVM and returns true or false
/// </summary>
/// <param name="condition">Logic source</param>
/// /// <param name="formContext">Data source</param>
/// <returns></returns>
public static bool EvaluateCondition(ConditionVM condition, FormVM formContext)
{
var result = false;
//Load in condition parameters
var variableName = condition.Logic.Variable;
var answer = condition.Logic.Answer;
//var answerArray = condition.Logic.AnswerArray;
var answerArray = answer.Split('|');
//Find variable in session formContext
string variable = null;
switch (condition.Logic.Source)
{
case "answer":
variable = formContext.GetQuestion(variableName).Answer;
break;
case "formData":
if (formContext.SubmissionData == null)
{
throw new Exception("No submissionData found");
}
variable = formContext.SubmissionData.Where(d => d.Id == variableName)
.Select(d => d.Value).FirstOrDefault();
break;
default:
throw new ArgumentException($"Unrecognised variable source type {condition.Logic.Source} supplied by form");
break;
}
if (variable == null) //Whitespace is now explicitly allowed, to allow for checking of empty answers
{
throw new Exception($"Unable to resolve dynamic content variable {variableName}");
}
//Set result to true if condition is met | CONSIDER making all of these individual methods
switch (condition.Logic.Operator)
{
case "equal":
result = answerArray.Any(variable.Equals); //(variable == answer);
break;
case "is_empty":
result = string.IsNullOrWhiteSpace(variable);
break;
case "not_equal":
result = !(answerArray.Any(variable.Equals)); //(variable != answer);
break;
//TODO: Consider inclusion of 'includes' and other string functions
case "contains":
result = answerArray.Any(variable.Contains);
break;
case "contains_all":
result = answerArray.All(variable.Contains);
break;
case "greater_than":
try
{
result = (float.Parse(variable) > float.Parse(answer));
}
catch
{
throw new ArgumentException($"Variable or answer {variable} cannot be parsed to float");
}
break;
case "greater_than_or_equal":
try
{
result = (float.Parse(variable) >= float.Parse(answer));
}
catch
{
throw new ArgumentException($"Variable or answer {variable} cannot be parsed to float");
}
break;
case "less_than":
try
{
result = (float.Parse(variable) < float.Parse(answer));
}
catch
{
throw new ArgumentException($"Variable or answer {variable} cannot be parsed to float");
}
break;
case "less_than_or_equal":
try
{
result = (float.Parse(variable) <= float.Parse(answer));
}
catch
{
throw new ArgumentException($"Variable or answer {variable} cannot be parsed to float");
}
break;
default:
throw new ArgumentException($"Unrecognised logic operator {condition.Logic.Operator} supplied by form");
break;
}
return(result);
}
public void HandleDynamicContentShouldApplyExpectedChanges()
{
//Arrange - this is a complex test so it uses a new pseudo-schema held entirely in the below variables:
var referenceForm = new FormVM()
{
SubmissionData = new List <DataItemVM>()
{
new DataItemVM()
{
Id = "InputDataItem-id",
Value = "InputDataItem-value"
}
},
Pages = new List <PageVM>()
{
new PageVM()
{
PageId = "ReferencePage",
PageName = "Reference Page",
Questions = new List <QuestionVM>()
{
new QuestionVM()
{
QuestionId = "Ref-Id",
Question = "Ref-Question",
DocumentOrder = 2,
InputType = "Ref-Type",
Answer = "Ref-Answer"
}
}
}
}
};
var questionCondition = new ConditionVM()
{
DevNotes = "Test condition set",
Logic = new LogicVM()
{
Source = "answer",
Variable = "Ref-Id",
Operator = "equal",
Answer = "Ref-Answer"
},
Priority = 1,
IfTrue = new IfTrueVM()
{
OverrideQuestion = new QuestionVM()
{
Answer = "Edited by question dynamic content",
AdditionalText = "Should-be-overwritten-by-subcondition",
ShortQuestion = "Added by question dynamic content"
},
Conditions = new List <ConditionVM>()
{
new ConditionVM()
{
DevNotes = "Test subcondition",
Logic = new LogicVM()
{
Source = "answer",
Variable = "Ref-Id",
Operator = "equal",
Answer = "Ref-Answer"
},
Priority = 1,
IfTrue = new IfTrueVM()
{
OverrideQuestion = new QuestionVM()
{
AdditionalText = "Overwritten field by question subcondition",
InputHeight = "Field added by subcondition"
}
}
}
}
}
};
var pageCondition = new ConditionVM()
{
DevNotes = "Test condition set for page-level",
Priority = 1,
Logic = new LogicVM()
{
Source = "formData",
Variable = "InputDataItem-id",
Operator = "equal",
Answer = "InputDataItem-value"
},
IfTrue = new IfTrueVM()
{
OverridePage = new PageVM()
{
NextPageId = "Added Field",
PageName = "Edited by page dynamic content"
}
}
};
var inputPage = new PageVM()
{
PageId = "TestPage",
PageName = "Test page",
DynamicContent = new DynamicContentVM()
{
Conditions = new List <ConditionVM>()
{
pageCondition
}
},
Questions = new List <QuestionVM>()
{
new QuestionVM()
{
QuestionId = "Test Question not-overwritten",
DynamicContent = new DynamicContentVM()
{
Conditions = new List <ConditionVM>()
{
questionCondition
}
},
}
}
};
var expectedOutput = new PageVM()
{
PageId = "TestPage",
PageName = "Edited by page dynamic content",
NextPageId = "Added Field",
DynamicContent = new DynamicContentVM()
{
Conditions = new List <ConditionVM>()
{
pageCondition
}
},
Questions = new List <QuestionVM>()
{
new QuestionVM()
{
QuestionId = "Test Question not-overwritten",
DynamicContent = new DynamicContentVM()
{
Conditions = new List <ConditionVM>()
{
questionCondition
}
},
Answer = "Edited by question dynamic content",
AdditionalText = "Overwritten field by question subcondition",
ShortQuestion = "Added by question dynamic content",
InputHeight = "Field added by subcondition"
}
}
};
//Act
var sut = inputPage;
sut.HandleDynamicContent(referenceForm);
//Assert
sut.Should().BeEquivalentTo(expectedOutput);
}
