public async Task WhenAnEmploymentCheckIsRequestedThenACheckIsRequestedForThePayeSchemesLinkedToTheEmployersAccount()
{
var request = new RequestEmploymentCheckForEmployerPayeSchemesRequest("AB12345C", 1324, 6543, 4353443, DateTime.Now.AddYears(-1));
var expectedAccountId = 349875;
_commitmentsApi.Setup(x => x.GetProviderApprenticeship(request.Ukprn, request.ApprenticeshipId)).ReturnsAsync(new Apprenticeship {
EmployerAccountId = expectedAccountId
});
var accountPayeSchemes = new List <ResourceViewModel>
{
new ResourceViewModel {
Id = "ABC/123"
},
new ResourceViewModel {
Id = "ZZZ/999"
}
};
var account = new AccountDetailViewModel {
PayeSchemes = new ResourceList(accountPayeSchemes)
};
_accountApiClient.Setup(x => x.GetAccount(expectedAccountId)).ReturnsAsync(account);
await _target.Handle(request);
_messagePublisher.Verify(
x => x.PublishAsync(It.Is <EmploymentCheckRequiredForAccountMessage>(y =>
y.Uln == request.Uln && y.ActualStartDate == request.ActualStartDate &&
y.EmployerAccountId == expectedAccountId &&
y.NationalInsuranceNumber == request.NationalInsuranceNumber && y.Ukprn == request.Ukprn &&
y.PayeSchemes.SequenceEqual(accountPayeSchemes.Select(z => z.Id)))), Times.Once());
}
public async Task <ActionResult> View(int?submitterId)
{
if (!User.IsSuperSubmitter())
{
return(RedirectToRoute(SiteRouteNames.Profile));
}
if (!submitterId.HasValue)
{
return(View("ResourceNotFound"));
}
var theSubmitter = await _submitterService.GetSubmitterAsync(submitterId.Value);
if (theSubmitter == null)
{
return(View("ResourceNotFound"));
}
var model = new AccountDetailViewModel
{
Submittership = theSubmitter,
ContactInfo = await _submitterService.GetContactDetailAsync(theSubmitter.SubmitterID)
};
return(View(model));
}
public async Task <IActionResult> AccountDetail(AccountDetailViewModel model)
{
string userID = User.FindFirstValue(ClaimTypes.NameIdentifier);
ApplicationUser user = await userManager.FindByIdAsync(userID);
user.PhoneNumber = model.PhoneNumber;
user.Email = model.Email;
user.FullName = model.FullName;
if (model.Password != null)
{
var token = await userManager.GeneratePasswordResetTokenAsync(user);
var result = await userManager.ResetPasswordAsync(user, token, model.Password);
if (result.Succeeded)
{
ModelState.AddModelError("", "Lưu thành công");
return(View(model));
}
ModelState.AddModelError("", "Đổi mật khẩu không thành công");
return(View(model));
}
ModelState.AddModelError("", "Lưu thành công");
return(View(model));
}
public IActionResult Register(AccountDetailViewModel viewmodel, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
Account inkomend = accountViewModelConverter.ViewModelToAccount(viewmodel);
if (!accountrepo.CheckAccountExist(inkomend))
{
if (accountrepo.Register(inkomend))
{
//geregistreerd
return(RedirectToAction("Login", "Account"));
}
else
{
//mislukt (fout met database)
return(RedirectToAction("Register", "Account"));
}
}
else
{
//mislukt (bestaat al)
return(RedirectToAction("Register", "Account"));
}
}
public IActionResult Login(AccountDetailViewModel viewmodel, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
Account inkomend = accountViewModelConverter.ViewModelToAccount(viewmodel);
Account opgehaald = accountrepo.Login(inkomend);
if (opgehaald.Email == inkomend.Email)
{
HttpContext.Session.SetInt32("AccountID", opgehaald.AccountID);
if (accountrepo.CheckRoleID(HttpContext.Session.GetInt32("AccountID")) == 2)
{
HttpContext.Session.SetInt32("Doctor", 1);
}
else if (accountrepo.CheckRoleID(HttpContext.Session.GetInt32("AccountID")) == 3)
{
HttpContext.Session.SetInt32("Admin", 1);
}
return(RedirectToAction("Index", "Home"));
}
else
{
return(View());
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
_objViewModel = new AccountDetailViewModel();
SourceContext();
//InitialOperations();
}
public void Arrange()
{
_userId = "ABC123";
_configuration = new AccountApiConfiguration
{
ApiBaseUrl = "http://some-url/"
};
_uri = $"/api/user/{_userId}/accounts";
var absoluteUri = _configuration.ApiBaseUrl.TrimEnd('/') + _uri;
_accountViewModel = new AccountDetailViewModel
{
HashedAccountId = "123ABC",
AccountId = 123,
DasAccountName = "Test Account",
DateRegistered = DateTime.Now.AddDays(-30),
};
var accounts = new List <AccountDetailViewModel> {
_accountViewModel
};
_httpClient = new Mock <SecureHttpClient>();
_httpClient.Setup(c => c.GetAsync(absoluteUri))
.Returns(Task.FromResult(JsonConvert.SerializeObject(accounts)));
_apiClient = new AccountApiClient(_configuration, _httpClient.Object);
}
public ActionResult Create()
{
var viewModel = new AccountDetailViewModel();
viewModel.ListRole = new SelectList(_roleService.GetListRoles(), "RoleId", "RoleName");
return(View(viewModel));
}
public async Task <IActionResult> Put(AccountDetailViewModel accountDetailViewModel)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(accountDetailViewModel.Email);
user.FullName = accountDetailViewModel.FullName;
user.PhoneNumber = accountDetailViewModel.PhoneNumber;
user.BirthDay = accountDetailViewModel.BirthDay;
if (accountDetailViewModel.Avatar != null)
{
user.Avatar = UploadImage(accountDetailViewModel.Avatar);
}
if (accountDetailViewModel.NewPassword != null && accountDetailViewModel.OldPassword != null)
{
var kq = await _userManager.ChangePasswordAsync(user, accountDetailViewModel.OldPassword,
accountDetailViewModel.NewPassword);
if (!kq.Succeeded)
{
return(new OkObjectResult(new GenericResult(false, "Mật Khẩu Cũ Không Khớp Vs Mật Khẩu Trong Hệ Thống")));
}
}
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(new OkObjectResult(new GenericResult(true, "Cập Nhật Thành Công")));
}
}
var allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
// GET: BankAccounts/Details/5
public ActionResult Details(int?id)
{
AccountDetailViewModel viewModel = new AccountDetailViewModel();
ControllerHelpers helper = new ControllerHelpers();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
viewModel.Account = db.Account.Find(id);
viewModel.Transactions = db.Transaction.Where(db => db.AccountId == viewModel.Account.Id).ToList();
if (viewModel.Account == null)
{
return(HttpNotFound());
}
ApplicationUser currUser = db.Users.Find(User.Identity.GetUserId());
if (currUser == null)
{
return(RedirectToAction("Login", "Account"));
}
List <Transaction> currTransactions = helper.GetTransactions(currUser);
List <AccountKey> AccountDisplay = helper.GetAccountDisplay(currUser);
viewModel.currTransactions = currTransactions;
viewModel.AccountId = new SelectList(AccountDisplay, "Id", "InstitutionName");
viewModel.CategoryId = new SelectList(db.Category, "Id", "Name");
viewModel.TypeTransactionId = new SelectList(db.TypeTransaction, "Id", "Name");
return(View(viewModel));
}
public IActionResult AccountInformation()
{
var model = new AccountDetailViewModel();
var _user = new AuthenticateResponse
{
MembershipKey = 1006979, //1007435,
EmailAddress = "*****@*****.**", //"*****@*****.**",
FirstName = "Tolulope",
LastName = "Olusakin",
FullName = "Olusakin Tolulope S"//"Funmilayo Ruth Adeyemi",
};
try
{
var customer = _client.GetUserProfile(_user.MembershipKey);
if (customer != null && customer.MembershipNumber > 0)
{
model.FullName = customer.FullName;
model.MembershipNumber = customer.MembershipNumber;
model.PhoneNumber = customer.PhoneNumber;
model.MobileNumber = customer.MobileNumber;
model.EmailAddress = customer.EmailAddress;
model.Address = customer.Address;
model.State = customer.State;
model.Country = customer.Country;
}
}
catch (Exception ex)
{
TempData["message"] = ViewBag.Message = ex.Message;
Utilities.ProcessError(ex, _contentRootPath);
_logger.LogError(null, ex, ex.Message);
}
return(View(model));
}
private async Task <Core.Models.Account> GetAdditionalFields(AccountDetailViewModel response, AccountFieldsSelection selection)
{
var result = MapToAccount(response);
switch (selection)
{
case AccountFieldsSelection.Organisations:
var legalEntities = await GetLegalEntities(response.LegalEntities ?? new ResourceList(new List <ResourceViewModel>()));
result.LegalEntities = legalEntities;
break;
case AccountFieldsSelection.TeamMembers:
var teamMembers = await GetAccountTeamMembers(result.HashedAccountId);
result.TeamMembers = teamMembers;
break;
case AccountFieldsSelection.PayeSchemes:
result.PayeSchemes = await MapToDomainPayeSchemeAsync(response);
return(result);
case AccountFieldsSelection.Finance:
result.PayeSchemes = await MapToDomainPayeSchemeAsync(response);
result.Transactions = await GetAccountTransactions(response.HashedAccountId);;
return(result);
}
return(result);
}
public async Task <ActionResult> CreateAsync(AccountDetailViewModel viewModel)
{
if (ModelState.IsValid)
{
Account account = _mapper.Map <Account>(viewModel);
var user = await _userManager.GetUserAsync(HttpContext.User);
var role = await _roleService.GetRoleById(viewModel.Roles);
if (role != null)
{
var result = _accountService.Insert(account, user.UserId, viewModel.Roles);
if (result)
{
await CreateUserAndApplyRoleAsync(account, Constants.DefaultPassword, role.RoleName);
return(RedirectToAction("Index"));
}
}
}
//if errror, return to view
ModelState.AddModelError(string.Empty, Constants.UnknowErrorMessage);
return(RedirectToAction("Create"));
}
public void Arrange()
{
_configuration = new AccountApiConfiguration
{
ApiBaseUrl = "http://some-url/"
};
_uri = "/api/accounts/ABC123";
var absoluteUri = _configuration.ApiBaseUrl.TrimEnd('/') + _uri;
_expectedAccount = new AccountDetailViewModel
{
AccountId = 123,
HashedAccountId = "1",
DasAccountName = "Account 1",
DateRegistered = DateTime.Now.AddYears(-1),
OwnerEmail = "*****@*****.**",
LegalEntities = new ResourceList(new[] { new ResourceViewModel {
Id = "1", Href = "/api/legalentities/test1"
} }),
PayeSchemes = new ResourceList(new[] { new ResourceViewModel {
Id = "1", Href = "/api/payeschemes/test1"
} })
};
_httpClient = new Mock <SecureHttpClient>();
_httpClient.Setup(c => c.GetAsync(absoluteUri)).Returns(Task.FromResult(JsonConvert.SerializeObject(_expectedAccount)));
_apiClient = new AccountApiClient(_configuration, _httpClient.Object);
}
public AccountDetailViewModel SelectByAccountId(int accountId)
{
AccountDetailViewModel model = new AccountDetailViewModel();
using (SqlConnection conn = new SqlConnection(connStr))
{
string cmdStr = "Account_Detail_SelectByAccountId";
using (SqlCommand cmd = new SqlCommand(cmdStr, conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@AccountId", accountId);
conn.Open();
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
int index = 0;
model.AccountId = reader.GetInt32(index++);
model.ProfilePicId = reader.GetInt32(index++);
model.PicturePath = System.Configuration.ConfigurationManager.AppSettings["AwsPath"] + reader.GetString(index++);
model.Description = reader.GetString(index++);
}
conn.Close();
}
}
return(model);
}
public IActionResult Update(AccountDetailViewModel model)
{
if (ModelState.IsValid)
{
var user = _mapper.Map <AccountDetailViewModel, Account>(model);
var updateuser = _authRepository.CheckByToken(_user.Token);
if (updateuser.Name != user.Name ||
updateuser.Surname != user.Surname ||
updateuser.Address != user.Address ||
updateuser.Birthday != user.Birthday ||
updateuser.Email != user.Email ||
updateuser.Website != user.Website ||
updateuser.Phone != user.Phone)
{
_authRepository.UpdateAccount(updateuser, user);
return(Ok(user));
}
}
return(View("Views/Pages/Chat1.cshtml", new GeneralViewModel
{
AccountDetailViewModel = model
}));
}
private async Task <IEnumerable <PayeSchemeViewModel> > GetPayeSchemes(AccountDetailViewModel response)
{
var result = new List <PayeSchemeViewModel>();
foreach (var payeScheme in response.PayeSchemes ?? new ResourceList(new List <ResourceViewModel>()))
{
var obscured = _payeSchemeObfuscator.ObscurePayeScheme(payeScheme.Id).Replace("/", "%252f");
var paye = payeScheme.Id.Replace("/", "%252f");
_logger.Debug(
$"IAccountApiClient.GetResource<PayeSchemeViewModel>(\"{payeScheme.Href.Replace(paye, obscured)}\");");
try
{
var payeSchemeViewModel = await _accountApiClient.GetResource <PayeSchemeViewModel>(payeScheme.Href);
if (IsValidPayeScheme(payeSchemeViewModel))
{
var item = new PayeSchemeViewModel
{
Ref = payeSchemeViewModel.Ref,
DasAccountId = payeSchemeViewModel.DasAccountId,
AddedDate = payeSchemeViewModel.AddedDate,
RemovedDate = payeSchemeViewModel.RemovedDate,
Name = payeSchemeViewModel.Name
};
result.Add(item);
}
}
catch (Exception e)
{
_logger.Error(e, $"Exception occured in Account API type of {nameof(LegalEntityViewModel)} at {payeScheme.Href} id {payeScheme.Id}");
}
}
return(result.OrderBy(x => x.Ref));
}
public async Task NavigateToAccountDetail(Account account)
{
var viewModel = new AccountDetailViewModel(account);
var page = new AccountDetailPage(viewModel);
await Application.Current.MainPage.Navigation.PushAsync(page);
}
public AccountDetailPage(Account account)
{
AccountDetailViewModel vm = new AccountDetailViewModel(account);
BindingContext = vm;
vm.UpdateSuccesfull += () => DisplayAlert("Succes", "Brugeren blev gemt", "OK");
vm.UpdateFailed += (Exception e) => DisplayAlert("Fejl", e.Message, "OK");
InitializeComponent();
}
public AccountDetailPage(PersonalAccount account)
{
vm = new AccountDetailViewModel(account, Navigation);
BindingContext = vm;
acct = account;
InitializeComponent();
}
private Core.Models.Account MapToAccount(AccountDetailViewModel accountDetailViewModel)
{
return(new Core.Models.Account
{
AccountId = accountDetailViewModel.AccountId,
DasAccountName = accountDetailViewModel.DasAccountName,
HashedAccountId = accountDetailViewModel.HashedAccountId,
DateRegistered = accountDetailViewModel.DateRegistered,
OwnerEmail = accountDetailViewModel.OwnerEmail
});
}
public async Task ThenTheAccountWithBalanceIsReturned()
{
var hashedAccountId = "ABC123";
var account = new AccountDetailViewModel
{
HashedAccountId = hashedAccountId,
AccountId = 123,
DateRegistered = DateTime.Now.AddYears(-1),
OwnerEmail = "*****@*****.**",
DasAccountName = "Test",
ApprenticeshipEmployerType = ApprenticeshipEmployerType.Levy.ToString(),
LegalEntities = new ResourceList(new List <ResourceViewModel> {
new ResourceViewModel {
Href = "/api/123", Id = "123"
}
}),
PayeSchemes = new ResourceList(new List <ResourceViewModel> {
new ResourceViewModel {
Href = "/api/XXX", Id = "XXX"
}
})
};
var accountBalanceResponse = new GetAccountBalancesResponse
{
Accounts = new List <AccountBalance> {
new AccountBalance {
AccountId = account.AccountId, Balance = 123.45m
}
}
};
ApiService.Setup(x => x.GetAccount(hashedAccountId, It.IsAny <CancellationToken>())).ReturnsAsync(account);
Mediator.Setup(x => x.SendAsync(It.Is <GetAccountBalancesRequest>(q => q.AccountIds.Single() == account.AccountId))).ReturnsAsync(accountBalanceResponse);
Mediator.Setup(x => x.SendAsync(It.IsAny <GetTransferAllowanceQuery>())).ReturnsAsync(new GetTransferAllowanceResponse {
TransferAllowance = new TransferAllowance()
});
var response = await Controller.GetAccount(hashedAccountId);
Assert.IsNotNull(response);
Assert.IsInstanceOf <OkNegotiatedContentResult <AccountDetailViewModel> >(response);
var model = response as OkNegotiatedContentResult <AccountDetailViewModel>;
model?.Content.Should().NotBeNull();
model?.Content?.DasAccountId.Should().Be(hashedAccountId);
model?.Content?.HashedAccountId.Should().Be(hashedAccountId);
model?.Content?.AccountId.Should().Be(account.AccountId);
model?.Content?.DasAccountName.Should().Be(account.DasAccountName);
model?.Content?.DateRegistered.Should().Be(account.DateRegistered);
model?.Content?.OwnerEmail.Should().Be(account.OwnerEmail);
model?.Content?.Balance.Should().Be(accountBalanceResponse.Accounts.Single().Balance);
}
// GET: Account/Edit/5
public IActionResult Edit(int id)
{
try
{
AccountDetailViewModel vm = converter.AccountToViewModel(_userManager.FindByIdAsync(id.ToString()).Result);
return(View(vm));
}
catch
{
return(RedirectToAction(nameof(Index)));
}
}
public CreateTransactionPage(int Id, AccountDetailViewModel vm)
{
ViewModel = new CreateTransactionViewModel(Navigation);
acctId = Id;
_personalAccount = vm.personalAccount;
InitializeComponent();
accountPicker.ItemsSource = ViewModel.accountList;
categoryPicker.ItemsSource = ViewModel.categoryList;
budgetPicker.ItemsSource = ViewModel.budgetList;
accountSection.IsVisible = false;
}
public async Task ItShouldReturnTheMatchingAccountWithOutLegalEntitiesThatAreOutOfScope(
EmployerAgreementStatus scope)
{
var id = "123";
var accountResponse = new AccountDetailViewModel
{
LegalEntities = new ResourceList(
new List <ResourceViewModel>
{
new ResourceViewModel {
Href = "https://tempuri.org/legalEntity/{id}", Id = "ABC"
}
})
};
AccountApiClient.Setup(x => x.GetResource <AccountDetailViewModel>($"/api/accounts/{id}"))
.ReturnsAsync(accountResponse);
var legalEntityResponse = new LegalEntityViewModel
{
AgreementStatus = scope
};
var legalEntity = accountResponse.LegalEntities[0];
AccountApiClient.Setup(x => x.GetResource <LegalEntityViewModel>(legalEntity.Href))
.ReturnsAsync(legalEntityResponse);
var actual = await _sut.Get(id, AccountFieldsSelection.Organisations);
Logger.Verify(
x => x.Debug(
$"{nameof(IAccountApiClient)}.{nameof(IAccountApiClient.GetResource)}<{nameof(AccountDetailViewModel)}>(\"/api/accounts/{id}\");"),
Times.Once);
Logger.Verify(
x => x.Debug(
$"{nameof(IAccountApiClient)}.{nameof(IAccountApiClient.GetResource)}<{nameof(LegalEntityViewModel)}>(\"{legalEntity.Href}\");"),
Times.Once);
AccountApiClient.Verify(x => x.GetResource <LegalEntityViewModel>(It.IsAny <string>()),
Times.Exactly(accountResponse.LegalEntities.Count));
Assert.IsNotNull(actual);
Assert.IsNotNull(actual.LegalEntities);
Assert.AreEqual(0, actual.LegalEntities.Count());
Assert.IsNull(actual.PayeSchemes);
Assert.IsNull(actual.Transactions);
Assert.IsNull(actual.TeamMembers);
}
public void Arrange()
{
_accountDetailViewModel = new AccountDetailViewModel
{
AccountId = AccountId,
ApprenticeshipEmployerType = "Levy"
};
_accountApiClient = new Mock <IAccountApiClient>();
_accountApiClient.Setup(x => x.GetAccount(It.IsAny <long>())).ReturnsAsync(_accountDetailViewModel);
_employerAccountService = new EmployerAccountService(_accountApiClient.Object);
}
public async Task <ActionResult> DetailAsync(int id = 0)
{
var account = await _accountService.GetAccountById(id);
if (account == null)
{
ModelState.AddModelError(string.Empty, Constants.UnknowErrorMessage);
return(RedirectToAction("Index"));
}
AccountDetailViewModel viewAccount = _mapper.Map <Account, AccountDetailViewModel>(account);
viewAccount.Role = string.Join(",", _roleService.GetRolesForAccount(account.AccountId).Select(n => n.RoleName));
return(View("Detail", viewAccount));
}
public void InsertIntoEmployerAccounts(dynamic value, ICollection <string> columns)
{
var empAccounts = new AccountDetailViewModel();
empAccounts.DasAccountName = columns.Contains("AccountName") ? value.AccountName : null;
empAccounts.DateRegistered = columns.Contains("DateRegistered") ? value.DateRegistered : DateTime.Now.AddDays(-100);
empAccounts.OwnerEmail = columns.Contains("OwnerEmail") ? value.OwnerEmail : "*****@*****.**";
empAccounts.HashedAccountId = columns.Contains("DasAccountId") ? value.DasAccountId : null;
empAccounts.AccountId = columns.Contains("AccountId") ? ConvertToType <long>(value.AccountId) : null;
var employeraccoutsrepo = new AccountRepository(_connectionString);
employeraccoutsrepo.SaveAccount(empAccounts).Wait();
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
try
{
string hashedAccountId = string.Empty;
if (filterContext.ActionParameters != null && filterContext.ActionParameters.ContainsKey("HashedAccountId"))
{
hashedAccountId = filterContext.ActionParameters["HashedAccountId"].ToString();
}
else if (filterContext.RouteData?.Values?.ContainsKey("HashedAccountId") == true)
{
hashedAccountId = filterContext.RouteData.Values["HashedAccountId"].ToString();
}
if (string.IsNullOrWhiteSpace(hashedAccountId))
{
filterContext.Result = new ViewResult {
ViewName = ControllerConstants.BadRequestViewName
};
return;
}
var accountApi = DependencyResolver.Current.GetService <IAccountApiClient>();
var task = Task.Run(async() => await accountApi.GetAccount(hashedAccountId));
AccountDetailViewModel account = task.Result;
ApprenticeshipEmployerType apprenticeshipEmployerType = (ApprenticeshipEmployerType)Enum.Parse(typeof(ApprenticeshipEmployerType), account.ApprenticeshipEmployerType, true);
if (apprenticeshipEmployerType == ApprenticeshipEmployerType.Levy)
{
base.OnActionExecuting(filterContext);
}
else
{
filterContext.Result = new RedirectToRouteResult(new RouteValueDictionary(
new
{
controller = ControllerConstants.AccessDeniedControllerName,
action = "Index",
}));
}
}
catch (Exception ex)
{
filterContext.Result = new ViewResult {
ViewName = ControllerConstants.BadRequestViewName
};
}
}
public AccountDetailViewModel ViewModelFromAccount(Account Account)
{
AccountDetailViewModel ADVM = new AccountDetailViewModel()
{
AccountID = Account.AccountID,
Name = Account.Name,
Email = Account.Email,
Password = Account.Password,
MeldingID = Account.MeldingID,
DateOfBirth = Account.DateOfBirth,
PhoneNumber = Account.PhoneNumber
};
return(ADVM);
}
