public void CaseProceedingModel_NextHearingBeforeProceeding()
{
// Arrange
var sut = new CaseProceedingModel
{
CaseProceedingId = 1,
JudgementFile = 0,
ProceedingDecision = 1,
ProceedingDate = DateTime.Today,
NextHearingOn = DateTime.Today.AddDays(-1)
};
var context = new ValidationContext(sut, null, null);
// Act
var results = new List <ValidationResult>();
var isModelStateValid = Validator.TryValidateObject(sut, context, results, true);
// Assert
Assert.False(isModelStateValid);
Assert.Single(results);
foreach (var item in results)
{
Assert.Equal("Proceeding Date cannot be later than Next Hearing date", item.ErrorMessage);
Assert.Single(item.MemberNames);
Assert.Contains("NextHearingOn", item.MemberNames);
}
}
private static bool IsEqual(CaseProceedingModel expected, CaseProceedingModel actual)
{
bool isEqual = expected.CaseProceedingId == actual.CaseProceedingId &&
expected.ProceedingDate == actual.ProceedingDate &&
expected.NextHearingOn == actual.NextHearingOn &&
expected.ProceedingDecision == actual.ProceedingDecision &&
expected.JudgementFile == actual.JudgementFile;
return(isEqual);
}
public async Task <ActionResult <CaseProceedingModel> > GetProceedingDetails(int caseProceedingId)
{
if (caseProceedingId < 1)
{
return(UnprocessableEntity($"Invalid CaseProceedingId: {caseProceedingId}"));
}
CaseProceedingModel caseProceeding = await _caseProceedingsService
.RetrieveAsync(caseProceedingId);
if (caseProceeding is null)
{
return(NotFound());
}
return(Ok(caseProceeding));
}
public async Task GetProceedingDetails_NotFound()
{
// Arrange
int caseProceedingId = 1;
CaseProceedingModel expected = null;
_mockCaseProceedingsService.RetrieveAsync(caseProceedingId).Returns(expected);
// Act
ActionResult <CaseProceedingModel> response = await _sut.GetProceedingDetails(caseProceedingId);
// Assert
await _mockCaseProceedingsService.Received(1).RetrieveAsync(caseProceedingId);
Assert.IsType <NotFoundResult>(response.Result);
}
public async Task UpdateAsync(CaseProceedingModel caseProceedingModel, int currUser)
{
var sqlModel = new SqlParamsModel
{
Sql = "pkg_case_proceedings.p_update_case_proceeding",
Parameters = new OracleDynamicParameters()
};
sqlModel.Parameters.Add("pi_case_proceeding_id", caseProceedingModel.CaseProceedingId, dbType: OracleMappingType.Int32, ParameterDirection.Input);
sqlModel.Parameters.Add("pi_proceeding_date", caseProceedingModel.ProceedingDate, dbType: OracleMappingType.Date, ParameterDirection.Input);
sqlModel.Parameters.Add("pi_proceeding_decision", caseProceedingModel.ProceedingDecision, dbType: OracleMappingType.Int32, ParameterDirection.Input);
sqlModel.Parameters.Add("pi_next_hearing_on", caseProceedingModel.NextHearingOn, dbType: OracleMappingType.Date, ParameterDirection.Input);
sqlModel.Parameters.Add("pi_judgement_file", caseProceedingModel.JudgementFile, dbType: OracleMappingType.Int32, ParameterDirection.Input);
sqlModel.Parameters.Add("pi_update_by", currUser, dbType: OracleMappingType.Int32, ParameterDirection.Input);
await _dataAccess.ExecuteAsync(sqlModel);
}
public async Task <IActionResult> UpdateCaseProceedingDetails(CaseProceedingModel caseProceedingModel)
{
if (ModelState.IsValid == false)
{
return(ValidationProblem());
}
ProceedingDecisionModel proceedingDecision = await _proceedingDecisionsService.RetrieveAsync(caseProceedingModel.ProceedingDecision);
if ((proceedingDecision.HasNextHearingDate != caseProceedingModel.NextHearingOn.HasValue) ||
(proceedingDecision.HasOrderAttachment != (caseProceedingModel.JudgementFile != 0)))
{
return(UnprocessableEntity("Proceeding Decision conditions not met"));
}
int currUser = _sessionService.GetUserId(HttpContext);
await _caseProceedingsService.UpdateAsync(caseProceedingModel, currUser);
return(NoContent());
}
public async Task GetProceedingDetails_Valid()
{
// Arrange
int caseProceedingId = 1;
CaseProceedingModel expected = GetSampleData_CaseProceedings().FirstOrDefault(x => x.CaseProceedingId == caseProceedingId);
_mockCaseProceedingsService.RetrieveAsync(caseProceedingId).Returns(expected);
// Act
ActionResult <CaseProceedingModel> response = await _sut.GetProceedingDetails(caseProceedingId);
// Assert
await _mockCaseProceedingsService.Received(1).RetrieveAsync(caseProceedingId);
var createdAtActionResult = Assert.IsType <OkObjectResult>(response.Result);
CaseProceedingModel actual = (CaseProceedingModel)createdAtActionResult.Value;
Assert.True(actual is not null);
Assert.Equal(expected.CaseProceedingId, actual.CaseProceedingId);
Assert.Equal(expected.ProceedingDate, actual.ProceedingDate);
Assert.Equal(expected.NextHearingOn, actual.NextHearingOn);
Assert.Equal(expected.ProceedingDecision, actual.ProceedingDecision);
Assert.Equal(expected.JudgementFile, actual.JudgementFile);
}
public Task <HttpResponseMessage> UpdateCaseProceedingAsync(CaseProceedingModel caseProceedingModel)
{
return(_http.PostAsJsonAsync($"{proceedingsBaseUrl}", caseProceedingModel));
}
