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 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 <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); }
private async Task PostConsentWithdrawn(Guid id, DecisionViewModel model) { await mediator.SendAsync(new WithdrawConsentForImportNotification(id, model.ReasonsForConsentWithdrawal, model.ConsentWithdrawnDate.AsDateTime().GetValueOrDefault())); }
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); }