public DisclaimerPage(UserRegistration userRegistration)
{
InitializeComponent();
var viewModel = new DisclaimerViewModel(userRegistration);
BindingContext = viewModel;
}
public void IndexPOST_GivenValidModelState_DisclaimerViewModelBuilderShouldBeCalled()
{
var model = new DisclaimerViewModel();
_controller.Index(model);
A.CallTo(() => _disclaimerViewModelBuilder.BuildAddDisclaimerCommand(model)).MustHaveHappened(Repeated.Exactly.Once);
}
public void IndexGET_GivenDisclaimer_DisclaimerModelShouldBeReturnedToView()
{
var model = new DisclaimerViewModel();
A.CallTo(() => _disclaimerViewModelBuilder.BuildDisclaimerViewModel(A <Disclaimer> ._)).Returns(model);
var result = _controller.Index() as ViewResult;
result.Model.Should().Be(model);
}
public void IndexPOST_GivenInvalidModelState_ModelShouldBeReturned()
{
var model = new DisclaimerViewModel();
_controller.ModelState.AddModelError("error", "error");
var result = _controller.Index(model) as ViewResult;
result.Model.Should().Be(model);
}
public DisclaimerPage()
{
InitializeComponent();
vm = new DisclaimerViewModel();
BindingContext = vm;
RegisterWebViewEvents();
RegisterOkPressed();
}
public void BuildAddDisclaimerCommand_GivenDecisionIdIsEmpty_DecisionIdShouldBeSet()
{
var disclaimer = new DisclaimerViewModel()
{
DisclaimerId = Guid.Empty
};
var result = _builder.BuildAddDisclaimerCommand(disclaimer);
result.DisclaimerId.Should().NotBeEmpty();
}
public void BuildAddDisclaimerCommand_GivenDecisionIsNotEmpty_DecisionIdShouldBeMapped()
{
var disclaimerId = Guid.NewGuid();
var disclaimer = new DisclaimerViewModel()
{
DisclaimerId = disclaimerId
};
var result = _builder.BuildAddDisclaimerCommand(disclaimer);
result.DisclaimerId.Should().Be(disclaimerId);
}
public virtual ActionResult Index(DisclaimerViewModel model)
{
if (ModelState.IsValid)
{
var command = _disclaimerViewModelBuilder.BuildAddDisclaimerCommand(model);
_commandDispatcher.Dispatch(command);
_unitOfWork.SaveChanges();
return(RedirectToAction(MVC.Home.Tutorial()));
}
return(View(model));
}
public async Task <ActionResult> Disclaimer(DisclaimerViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await mediator.SendAsync(new SubmitNotification(model.Id));
if (User.IsInternalUser())
{
return(RedirectToAction("Index", "KeyDates", new { area = "AdminExportAssessment", id = model.Id }));
}
return(RedirectToAction("Index", "WhatToDoNext", new { id = model.Id }));
}
public async Task<ActionResult> Disclaimer(DisclaimerViewModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
await mediator.SendAsync(new SubmitNotification(model.Id));
if (User.IsInternalUser())
{
return RedirectToAction("Index", "KeyDates", new { area = "AdminExportAssessment", id = model.Id });
}
return RedirectToAction("Index", "WhatToDoNext", new { id = model.Id });
}
public void BuildAddDisclaimerCommand_GivenValidDisclaimerViewModel_AddDisclaimerCommand()
{
var disclaimerId = Guid.NewGuid();
const bool isAgreed = true;
var disclaimer = new DisclaimerViewModel()
{
DisclaimerId = disclaimerId,
IsAgreed = isAgreed
};
var result = _builder.BuildAddDisclaimerCommand(disclaimer);
result.DisclaimerId.Should().NotBeEmpty();
result.IsAgreed.ShouldBeEquivalentTo(true);
}
public AddUpdateDisclaimerCommand BuildAddDisclaimerCommand(DisclaimerViewModel disclaimer)
{
if (disclaimer == null)
{
throw new ArgumentNullException("disclaimer");
}
var command = Mapper.DynamicMap <DisclaimerViewModel, AddUpdateDisclaimerCommand>(disclaimer);
if (command.DisclaimerId == Guid.Empty)
{
command.DisclaimerId = Guid.NewGuid();
}
return(command);
}
public async Task<ActionResult> Disclaimer(Guid id)
{
var assessmentInfo =
await mediator.SendAsync(new GetNotificationAssessmentSummaryInformation(id));
var status = assessmentInfo.Status;
if (status == NotificationStatus.NotSubmitted)
{
var model = new DisclaimerViewModel
{
Id = id,
CompetentAuthority = assessmentInfo.CompetentAuthority
};
return View(model);
}
ViewBag.NotificationId = id;
return View("AlreadySubmitted");
}
public async Task <ActionResult> Disclaimer(Guid id)
{
var assessmentInfo =
await mediator.SendAsync(new GetNotificationAssessmentSummaryInformation(id));
var status = assessmentInfo.Status;
if (status == NotificationStatus.NotSubmitted)
{
var model = new DisclaimerViewModel
{
Id = id,
CompetentAuthority = assessmentInfo.CompetentAuthority
};
return(View(model));
}
ViewBag.NotificationId = id;
return(View("AlreadySubmitted"));
}
/// <summary>
///
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
/// <exception cref="FriendlyException"></exception>
public async Task DisclaimerResponse(DisclaimerViewModel model)
{
const string methodName = "DisclaimerResponse";
string debugStr = "";
Logger.WriteDebug($"{methodName} called.");
try
{
if (model == null)
{
throw new FriendlyException(FriendlyExceptionType.InvalidModelState);
}
if (!model.Agreed)
{
throw new FriendlyException(FriendlyExceptionType.AccessDenied);
}
if (string.IsNullOrWhiteSpace(model.DeviceSessionId))
{
throw new FriendlyException(FriendlyExceptionType.AccessDenied);
}
if (string.IsNullOrWhiteSpace(model.DeviceGuid))
{
throw new FriendlyException(FriendlyExceptionType.DeviceIsNotSupported);
}
if (string.IsNullOrWhiteSpace(model.Badge))
{
throw new FriendlyException(FriendlyExceptionType.AccessDenied);
}
// --------------------------------------some sanity check!
if (model.Badge?.Length > 10)
{
throw new FriendlyException(FriendlyExceptionType.AccessDenied, "Badge is too long.");
}
//----------------------------------------
var badge = model.Badge?.Trim().PadLeft(6, '0');
debugStr = "Before getting Demo User for badge: " + badge;
var user = await RestroomUnitOfWork.Get <User>().FirstOrDefaultAsync(m => m.Badge == badge);
if (user == null)
{
throw new FriendlyException(FriendlyExceptionType.AccessHasBeenRevoked, "", debugStr);
}
if (!user.Active)
{
throw new FriendlyException(FriendlyExceptionType.AccessDeniedNotActive, "", debugStr);
}
//var demoUser = await IsDemoUserAsync(operatorInfo.FirstName, operatorInfo.LastName, badge);
var demoUser = user.IsDemo.GetValueOrDefault(false);
debugStr = "After getting Demo User: "******"After getting Employee, DemoUser: {demoUser}, Found:{(employee != null)}";
if (employee == null && !demoUser)
{
var s = $"{methodName}. Employee not found." + $"debugStr: {debugStr}";
Logger.Write(s);
WriteLog(model, s);
throw new FriendlyException(FriendlyExceptionType.AccessDenied);
}
if (demoUser)
{
CurrentUserName = "******";
}
else
{
CurrentUserName = employee.Name;
}
debugStr = $"Getting device for {model.DeviceGuid}";
var device = await RestroomUnitOfWork.Get <Device>()
.FirstOrDefaultAsync(m => m.DeviceGuid == model.DeviceGuid);
if (device == null || !device.Active)
{
throw new FriendlyException(FriendlyExceptionType.AccessDeniedNotActive, $"debugStr: {debugStr}");
}
debugStr = $"Getting userDevice for device:{model.DeviceGuid} and user: {user.UserId}";
var userDevice = await RestroomUnitOfWork.Get <UserDevice>()
.FirstOrDefaultAsync(m => m.DeviceId == device.DeviceId && m.UserId == user.UserId);
if (userDevice == null || !userDevice.Active)
{
throw new FriendlyException(FriendlyExceptionType.AccessDeniedNotActive, $"debugStr: {debugStr}");
}
var confirmation = new Confirmation
{
Badge = badge,
Agreed = model.Agreed,
IncidentDateTime = model.IncidentDateTime,
DeviceId = model.DeviceGuid,
SessionId = model.DeviceSessionId,
Active = true
};
RestroomUnitOfWork.PrepConfirmation(confirmation);
await RestroomUnitOfWork.SaveChangesAsync();
}
catch (FriendlyException ex)
{
Logger.WriteError("debugStr:" + debugStr + ", Error:" + ex.Message);
throw;
}
catch (DbEntityValidationException ex)
{
Logger.WriteError("DbEntityValidationException, debugStr:" + debugStr + ", Error:" + ex.Message);
foreach (var eve in ex.EntityValidationErrors)
{
Logger.WriteError($"Entity of type \"{eve.Entry.Entity.GetType().Name}\" in state \"{eve.Entry.State}\" has the following validation errors:");
foreach (var ve in eve.ValidationErrors)
{
Logger.WriteError($"- Property: \"{ve.PropertyName}\", Error: \"{ve.ErrorMessage}\"");
}
}
throw new FriendlyException(FriendlyExceptionType.Other, "Server could not process your request. please try again later.");
}
catch (Exception ex)
{
Logger.WriteError("debugStr:" + debugStr + ", Error:" + ex.Message);
throw new FriendlyException(FriendlyExceptionType.Other, "Server could not process your request. please try again later.");
}
}
public GoToPersonalDataProtectionCommand(DisclaimerViewModel viewModel)
{
disclaimerViewModel = viewModel;
}
// GET: Disclaimer
public async Task <IHttpActionResult> DisclaimerResponse(DisclaimerViewModel model)
{
await Handler.DisclaimerResponse(model);
return(Ok());
}
