public async Task <DecisionViewModel> CreateDecision()
{
DecisionViewModel decisionViewModel = null;
try
{
var organizations = _mapper.Map <IEnumerable <Organization> >(await _decisionService.GetOrganizationListAsync());
decisionViewModel = new DecisionViewModel
{
DecisionWrapper = _mapper.Map <DecisionWrapper>(_decisionService.CreateDecision()),
OrganizationListItems = from item in organizations
select new SelectListItem
{
Text = item.OrganizationName,
Value = item.ID.ToString()
},
DecisionTargets = _mapper.Map <IEnumerable <DecisionTarget> >(await _decisionService.GetDecisionTargetListAsync()),
DecisionStatusTypeListItems = _decisionService.GetDecisionStatusTypes()
};
}
catch (Exception e)
{
_loggerService.LogError($"{e.Message}");
}
return(decisionViewModel);
}
public async Task <JsonCamelCaseResult> SaveDecision(DecisionViewModel decision)
{
// Save Decision.
var update = await Factory.SaveAsync(Mapper.Map <IDecisionDto>(decision));
// Return.
return(new JsonCamelCaseResult(update));
}
public async Task <ActionResult> Index(Guid id)
{
var data = await mediator.SendAsync(new GetImportNotificationAssessmentDecisionData(id));
var model = new DecisionViewModel(data);
return(View(model));
}
private async Task PostConsent(Guid id, DecisionViewModel model)
{
await mediator.SendAsync(new Consent(id,
model.ConsentValidFromDate.AsDateTime().GetValueOrDefault(),
model.ConsentValidToDate.AsDateTime().GetValueOrDefault(),
model.ConsentConditions,
model.ConsentGivenDate.AsDateTime().GetValueOrDefault()));
}
public void Delete(DecisionViewModel model)
{
var item = _repository.FindById(model.Id);
if (item != null)
{
_repository.Delete(item);
}
}
public async Task ValidConsentData_Posts()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
await decisionController.Index(notificationId, model);
A.CallTo(() => mediator.SendAsync(A<Consent>.Ignored)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task ConsentGivenDate_Today_Valid()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
model.ConsentGivenDate = new OptionalDateInputViewModel(Today);
await decisionController.Index(notificationId, model);
Assert.True(decisionController.ModelState.IsValid);
}
public async Task ConsentGivenDate_InFuture_Invalid()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
model.ConsentGivenDate = new OptionalDateInputViewModel(Today.AddDays(1));
await decisionController.Index(notificationId, model);
Assert.True(decisionController.ModelState.ContainsKey("ConsentGivenDate"));
}
public async Task InvalidModel_ReturnsView()
{
var model = new DecisionViewModel();
model.DecisionTypes.Insert(0, DecisionType.Consent);
decisionController.ModelState.AddModelError("Test", "Error");
var result = await decisionController.Index(notificationId, model) as ViewResult;
Assert.Equal(string.Empty, result.ViewName);
}
public async Task ValidConsentData_Posts()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
await decisionController.Index(notificationId, model);
A.CallTo(() => mediator.SendAsync(A <Consent> .Ignored)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task ConsentGivenDate_InFuture_Invalid()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
model.ConsentGivenDate = new OptionalDateInputViewModel(Today.AddDays(1));
await decisionController.Index(notificationId, model);
Assert.True(decisionController.ModelState.ContainsKey("ConsentGivenDate"));
}
public async Task ConsentGivenDate_Today_Valid()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
model.ConsentGivenDate = new OptionalDateInputViewModel(Today);
await decisionController.Index(notificationId, model);
Assert.True(decisionController.ModelState.IsValid);
}
public async Task ValidFromDate_BeforeAcknowledgedOnDate_Invalid()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
model.ConsentValidFromDate = new OptionalDateInputViewModel(acknowledgedOnDate.AddDays(-1));
await decisionController.Index(notificationId, model);
Assert.True(decisionController.ModelState.ContainsKey("ConsentValidFromDate"));
}
public async Task ConsentGivenDate_AfterAcknowledgedOnDate_Valid()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
model.ConsentGivenDate = new OptionalDateInputViewModel(acknowledgedOnDate.AddDays(1));
await decisionController.Index(notificationId, model);
Assert.True(decisionController.ModelState.IsValid);
}
/// <summary>
/// Counts the decision.
/// </summary>
/// <param name="decision">The decision.</param>
public DecisionViewModel CountDecision(DecisionViewModel decision)
{
Model.DecisionModels.Decision workflowDecision = Mapper.Map <Model.DecisionModels.Decision>(decision);
foreach (IDecisionExecutionComponent decisionExecutionComponent in this.DecisionExecutionComponents)
{
decisionExecutionComponent.Execute(workflowDecision);
}
return(Mapper.Map <DecisionViewModel>(workflowDecision));
}
public async Task InvalidModel_ReturnsView()
{
var model = new DecisionViewModel();
model.DecisionTypes.Insert(0, DecisionType.Consent);
decisionController.ModelState.AddModelError("Test", "Error");
var result = await decisionController.Index(notificationId, model) as ViewResult;
Assert.Equal(string.Empty, result.ViewName);
}
public async Task <ActionResult> Index(Guid id, DecisionViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
switch (model.Decision)
{
case DecisionType.Consent:
if (await ConsentDatesAreValid(id, model))
{
await PostConsent(id, model);
}
else
{
return(View(model));
}
break;
case DecisionType.ConsentWithdraw:
if (await ConsentWithdrwanDateIsValid(id, model))
{
await PostConsentWithdrawn(id, model);
}
else
{
return(View(model));
}
break;
case DecisionType.Object:
await PostObjection(id, model);
break;
case DecisionType.Withdraw:
if (await WithdrawDateIsValid(id, model))
{
await PostWithdrawn(id, model);
}
else
{
return(View(model));
}
break;
default:
break;
}
return(RedirectToAction("Index", "KeyDates"));
}
public ActionResult Delete(DecisionViewModel model)
{
try
{
service.Delete(model);
service.Save();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public void DecisionWorkflowCountDecision_PassedNormalData_returnsCorrectData()
{
AutoMapperConfiguration.Configure();
this.DecisionWorkflow = this.DependencyResolver.GetService <IDecisionWorkflow>();
DecisionViewModel workingDecision = this.GetTestData();
DecisionViewModel result = this.DecisionWorkflow.CountDecision(workingDecision);
IEnumerable <bool> assertResult = result.DecisionArray.Select(x => Math.Abs(x.FinalRate - 33) < 1);
Assert.IsNotNull(result.DecisionArray.Any(x => Math.Abs(x.FinalRate - 33) < 1));
Assert.IsTrue(assertResult.Count() == 3);
}
public async Task SaveDecisionWithIncorrectFileTest()
{
DecisionViewModel decisionViewModel = CreateDecisionViewModel();
decisionViewModel.DecisionWrapper.File = new FormFile(null, 1234, 11241234, "fdd", "dfsdf");
DecisionController documentationController = CreateDocumentationController;
JsonResult jsonResult = await documentationController.SaveDecision(decisionViewModel.DecisionWrapper);
bool actual = jsonResult.Value.ToString().Contains("file length > 10485760");
Assert.True(actual);
}
public async Task CreateDecisionFailTest()
{
_mapper.Setup(m => m.Map <IEnumerable <Organization> >(It.IsAny <IEnumerable <OrganizationDTO> >()))
.Returns(() => null);
_mapper.Setup(m => m.Map <IEnumerable <DecisionWrapper> >(It.IsAny <IEnumerable <DecisionWrapperDTO> >()))
.Returns(new List <DecisionWrapper>());
_mapper.Setup(m => m.Map <IEnumerable <DecisionTarget> >(It.IsAny <IEnumerable <DecisionTargetDTO> >()))
.Returns(new List <DecisionTarget>());
_decisionService.Setup(d => d.GetDecisionStatusTypes()).Returns(new List <SelectListItem>());
DecisionController documentationController = CreateDocumentationController;
DecisionViewModel decisionViewModel = await documentationController.CreateDecision();
Assert.True(decisionViewModel == null);
}
public void Update(DecisionViewModel model)
{
var contractType = AutoMapper.Mapper.Map <DecisionViewModel, Decision>(model);
if (string.IsNullOrEmpty(contractType.Document))
{
var old = _repository.FindById(model.Id);
if (old != null)
{
contractType.Document = old.Document;
}
}
_repository.Update(contractType);
}
private async Task <bool> ConsentDatesAreValid(Guid id, DecisionViewModel model)
{
bool areValid = true;
var data = await mediator.SendAsync(new GetImportNotificationAssessmentDecisionData(id));
if (model.ConsentGivenDate.AsDateTime() > SystemTime.UtcNow)
{
ModelState.AddModelError("ConsentGivenDate", DecisionControllerResources.ConsentedNotInFuture);
areValid = false;
}
if (model.ConsentGivenDate.AsDateTime() < data.AcknowledgedOnDate)
{
ModelState.AddModelError("ConsentGivenDate", DecisionControllerResources.ConsentedNotBeforeAcknowledged);
areValid = false;
}
if (model.ConsentValidFromDate.AsDateTime() < data.AcknowledgedOnDate)
{
ModelState.AddModelError("ConsentValidFromDate", DecisionControllerResources.ValidFromNotBeforeAcknowledged);
areValid = false;
}
if (model.ConsentValidToDate.AsDateTime() <= SystemTime.UtcNow.Date)
{
ModelState.AddModelError("ConsentValidToDate", DecisionControllerResources.ValidToMustBeInFuture);
areValid = false;
}
DateTime validFromDate = model.ConsentValidFromDate.AsDateTime().GetValueOrDefault();
if (data.IsPreconsented.Value && model.ConsentValidToDate.AsDateTime() >= validFromDate.AddYears(3))
{
ModelState.AddModelError("ConsentValidToDate", DecisionControllerResources.ValidFromPreconsented);
areValid = false;
}
if ((!data.IsPreconsented.Value) && model.ConsentValidToDate.AsDateTime() >= validFromDate.AddYears(1))
{
ModelState.AddModelError("ConsentValidToDate", DecisionControllerResources.ValidFromNotPreconsented);
areValid = false;
}
return(areValid);
}
private async Task <bool> ConsentWithdrwanDateIsValid(Guid id, DecisionViewModel model)
{
bool isValid = true;
var consentedDate = await mediator.SendAsync(new GetImportNotificationConsentedDate(id));
if (model.ConsentWithdrawnDate.AsDateTime() > SystemTime.UtcNow)
{
ModelState.AddModelError("ConsentWithdrawnDate", DecisionControllerResources.ConsentWithdrawnNotInFuture);
isValid = false;
}
if (model.ConsentWithdrawnDate.AsDateTime() < consentedDate.GetValueOrDefault())
{
ModelState.AddModelError("ConsentWithdrawnDate", DecisionControllerResources.ConsentWithdrawnNotBeforeConsented);
isValid = false;
}
return(isValid);
}
private async Task <bool> WithdrawDateIsValid(Guid id, DecisionViewModel model)
{
bool isValid = true;
var data = await mediator.SendAsync(new GetImportNotificationAssessmentDecisionData(id));
if (model.WithdrawnDate.AsDateTime() > SystemTime.UtcNow)
{
ModelState.AddModelError("WithdrawnDate", DecisionControllerResources.WithdrawNotInFuture);
isValid = false;
}
if (model.WithdrawnDate.AsDateTime() < data.NotificationReceivedDate)
{
ModelState.AddModelError("WithdrawnDate", DecisionControllerResources.WithdrawNotBeforeReceived);
isValid = false;
}
return(isValid);
}
public ActionResult Create(DecisionViewModel model)
{
try
{
if (ModelState.IsValid)
{
var f = Request.Files["Document"];
if (f != null && f.ContentLength > 0)
{
string pic = System.IO.Path.GetFileName(f.FileName);//System.IO.Path.GetFileName(f.FileName);
var avatarpath = "/Uploads/Lichsuquyetdinhs";
string path = System.IO.Path.Combine(Server.MapPath(avatarpath), pic);
// file is uploaded
f.SaveAs(path);
using (MemoryStream ms = new MemoryStream())
{
f.InputStream.CopyTo(ms);
byte[] array = ms.GetBuffer();
}
model.Document = string.Join("/", avatarpath, pic);
}
service.Insert(model);
service.Save();
return(RedirectToAction("Index", "Decision", new { employeeId = model.EmployeeId }));
}
var employees = employee.GetEmployeeSelectListItems().Select(x => new {
Id = x.Id,
Name = x.Id + " - " + x.FirstName + " " + x.LastName
}).ToList();
ViewBag.Employees = new SelectList(employees, "Id", "Name");
var decisiontypes = _decisiontypeService.GetDecisionTypes();
ViewBag.DecisionTypes = new SelectList(decisiontypes, "Id", "Name");
return(View(model));
}
catch (Exception e)
{
return(View(model));
}
}
public async Task SaveDecisionCorrectTest()
{
_mapper.Setup(m => m.Map <DecisionWrapperDTO>(It.IsAny <DecisionWrapper>()))
.Returns(new DecisionWrapperDTO());
_decisionService.Setup(d => d.SaveDecisionAsync(It.IsAny <DecisionWrapperDTO>()))
.Returns(Task.FromResult(5));
_decisionService.Setup(d => d.GetDecisionOrganizationAsync(It.IsAny <OrganizationDTO>()))
.ReturnsAsync(new OrganizationDTO {
OrganizationName = string.Empty
});
DecisionViewModel decisionViewModel = CreateDecisionViewModel();
DecisionController documentationController = CreateDocumentationController;
JsonResult jsonResult = await documentationController.SaveDecision(decisionViewModel.DecisionWrapper);
bool actual = jsonResult.Value.ToString().Contains("True");
Assert.True(actual);
}
public async Task ValidToDate_Preconsented_GreaterThanThreeYearsFromValidFromDate_Invalid()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
model.ConsentValidFromDate = new OptionalDateInputViewModel(Today);
model.ConsentValidToDate = new OptionalDateInputViewModel(Today.AddYears(3));
A.CallTo(() => mediator.SendAsync(A <GetImportNotificationAssessmentDecisionData> .Ignored))
.Returns(new ImportNotificationAssessmentDecisionData
{
AcknowledgedOnDate = acknowledgedOnDate,
IsPreconsented = true
});
await decisionController.Index(notificationId, model);
Assert.True(decisionController.ModelState.ContainsKey("ConsentValidToDate"));
}
public async Task ValidToDate_NotPreconsented_UpToOneYearFromValidFromDate_Valid()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
model.ConsentValidFromDate = new OptionalDateInputViewModel(Today);
model.ConsentValidToDate = new OptionalDateInputViewModel(Today.AddYears(1).AddDays(-1));
A.CallTo(() => mediator.SendAsync(A <GetImportNotificationAssessmentDecisionData> .Ignored))
.Returns(new ImportNotificationAssessmentDecisionData
{
AcknowledgedOnDate = acknowledgedOnDate,
IsPreconsented = false
});
await decisionController.Index(notificationId, model);
Assert.True(decisionController.ModelState.IsValid);
}
public async Task ConsentGivenDate_AfterAcknowledgedOnDate_Valid()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
model.ConsentGivenDate = new OptionalDateInputViewModel(acknowledgedOnDate.AddDays(1));
await decisionController.Index(notificationId, model);
Assert.True(decisionController.ModelState.IsValid);
}
private async Task PostConsentWithdrawn(Guid id, DecisionViewModel model)
{
await mediator.SendAsync(new WithdrawConsentForImportNotification(id,
model.ReasonsForConsentWithdrawal,
model.ConsentWithdrawnDate.AsDateTime().GetValueOrDefault()));
}
public async Task ValidFromDate_BeforeAcknowledgedOnDate_Invalid()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
model.ConsentValidFromDate = new OptionalDateInputViewModel(acknowledgedOnDate.AddDays(-1));
await decisionController.Index(notificationId, model);
Assert.True(decisionController.ModelState.ContainsKey("ConsentValidFromDate"));
}
public void Insert(DecisionViewModel model)
{
var contractType = AutoMapper.Mapper.Map <DecisionViewModel, Decision>(model);
_repository.Add(contractType);
}
public DecisionViewModel Post([FromBody] DecisionViewModel decisionViewModel)
{
return(this.DecisionWorkflow.CountDecision(decisionViewModel));
}
private async Task PostObjection(Guid id, DecisionViewModel model)
{
await mediator.SendAsync(new ObjectToImportNotification(id,
model.ReasonForObjection,
model.ObjectionDate.AsDateTime().GetValueOrDefault()));
}
public async Task ValidToDate_Preconsented_GreaterThanThreeYearsFromValidFromDate_Invalid()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
model.ConsentValidFromDate = new OptionalDateInputViewModel(Today);
model.ConsentValidToDate = new OptionalDateInputViewModel(Today.AddYears(3));
A.CallTo(() => mediator.SendAsync(A<GetImportNotificationAssessmentDecisionData>.Ignored))
.Returns(new ImportNotificationAssessmentDecisionData
{
AcknowledgedOnDate = acknowledgedOnDate,
IsPreconsented = true
});
await decisionController.Index(notificationId, model);
Assert.True(decisionController.ModelState.ContainsKey("ConsentValidToDate"));
}
public DecisionsPage()
{
InitializeComponent();
DataContext = new DecisionViewModel();
}
public async Task ValidToDate_NotPreconsented_UpToOneYearFromValidFromDate_Valid()
{
var model = new DecisionViewModel();
model.Decision = DecisionType.Consent;
model.ConsentValidFromDate = new OptionalDateInputViewModel(Today);
model.ConsentValidToDate = new OptionalDateInputViewModel(Today.AddYears(1).AddDays(-1));
A.CallTo(() => mediator.SendAsync(A<GetImportNotificationAssessmentDecisionData>.Ignored))
.Returns(new ImportNotificationAssessmentDecisionData
{
AcknowledgedOnDate = acknowledgedOnDate,
IsPreconsented = false
});
await decisionController.Index(notificationId, model);
Assert.True(decisionController.ModelState.IsValid);
}
