public async Task <IActionResult> PostAccountAsync([FromBody] Account account) { await _accountService.AddAccount(account); var newAccount = await _accountService.GetAccount(account.Email); return(StatusCode(201, newAccount)); }
private async Task CreateAccount(CreateApplicationCommand request) { var accountData = await _accountsService.GetAccount(request.EncodedAccountId); await _levyTransferMatchingService.CreateAccount(new CreateAccountRequest(request.EmployerAccountId, accountData.DasAccountName)); }
private async Task attachUserToContext(HttpContext context, IAccountsService accountService, string token) { try { var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(_appSettings.Secret); tokenHandler.ValidateToken(token, new TokenValidationParameters { ValidateIssuerSigningKey = true, IssuerSigningKey = new SymmetricSecurityKey(key), ValidateIssuer = false, ValidateAudience = false, // set clockskew to zero so tokens expire exactly at token expiration time (instead of 5 minutes later) ClockSkew = TimeSpan.Zero }, out SecurityToken validatedToken); var jwtToken = (JwtSecurityToken)validatedToken; var email = jwtToken.Claims.First(x => x.Type == "email").Value; // attach user to context on successful jwt validation context.Items["Account"] = await accountService.GetAccount(email); } catch { // do nothing if jwt validation fails // user is not attached to context so request won't have access to secure routes } }
public async Task <GetAccountResult> Handle(GetAccountQuery request, CancellationToken cancellationToken) { var account = await _accountsService.GetAccount(request.EncodedAccountId); return(new GetAccountResult() { Account = account, }); }
public async Task <IViewComponentResult> InvokeAsync(string selectedTab) { var account = await _accountsService.GetAccount(AccountIdentification.ByGlobalUserId(((ClaimsPrincipal)User).GetUserId())); return(View(new SideBarViewModel { SelectedTab = selectedTab, Amount = account?.CurrentBalance ?? 0 })); }
public async Task <GetAmountQueryResult> Handle(GetAmountQuery request, CancellationToken cancellationToken) { var account = await _accountsService.GetAccount(request.EncodedAccountId); return(new GetAmountQueryResult { RemainingTransferAllowance = account.RemainingTransferAllowance, DasAccountName = account.DasAccountName }); }
public async Task ProcessTransaction(Transaction transaction) { ValidateTransactionAmount(transaction); ValidateTransactionAccounts(transaction); Console.WriteLine("TransactionsService: Started processing transaction."); var fromAccount = await _accountsService.GetAccount(transaction.FromAccountId); ValidateAccountHasEnoughMoney(fromAccount.Balance, transaction.Amount); var toAccount = await _accountsService.GetAccount(transaction.ToAccountId); await _transactionSemaphore.WaitAsync(); try { fromAccount = await _accountsService.GetAccount(transaction.FromAccountId); ValidateAccountHasEnoughMoney(fromAccount.Balance, transaction.Amount); toAccount = await _accountsService.GetAccount(transaction.ToAccountId); fromAccount.Balance -= transaction.Amount; await _accountsService.UpdateAccount(fromAccount); toAccount.Balance += transaction.Amount; await _accountsService.UpdateAccount(toAccount); var transactionEntity = _mapper.Map <TransactionEntity>(transaction); await _transactionsRepository.AddTransaction(transactionEntity); } catch (Exception ex) { Console.WriteLine($"Transaction failed ({ex.Message})"); throw; } finally { _transactionSemaphore.Release(); } }
public IEnumerable <Group> ListGroups(long?accountId) { if (accountId.HasValue) { var account = _accountsService.GetAccount(accountId.Value); return(account.Groups); } var accounts = _accountsService.ListAccounts(); return(accounts.SelectMany(a => a.Groups).ToArray()); }
public IHttpActionResult GetAccount(int id) { Account account = accountsService.GetAccount(id); if (account == null) { return(NotFound()); } return(Ok(account)); }
protected async override void OnPublished(object data) { if (isOpen) { return; } IsBusy = true; if (Messages != null && Messages.Any()) { ClearMessages(); } accountViewModel.Dispatcher = ViewModelContext.UiDispatcher; symbolsViewModel.Dispatcher = ViewModelContext.UiDispatcher; tradeViewModel.Dispatcher = ViewModelContext.UiDispatcher; ordersViewModel.Dispatcher = ViewModelContext.UiDispatcher; Account = new Account(new Interface.AccountInfo { User = new Interface.User() }); try { userAccount = await accountsService.GetAccount(Title); var json = JsonConvert.SerializeObject(userAccount, Formatting.Indented); Logger.Log(json, Category.Info, Priority.Medium); } catch (Exception ex) { TradeViewModelException(ex.ToString(), ex); } if (userAccount != null && userAccount.Preferences != null) { if (!string.IsNullOrWhiteSpace(userAccount.ApiKey)) { Account.ApiKey = userAccount.ApiKey; Account.ApiSecret = userAccount.ApiSecret; } } SymbolsViewModel.SetAccount(userAccount); AccountViewModel.SetAccount(account); isOpen = true; IsBusy = false; }
public async Task <ActionResult <PagedResults <AccountResponse> > > GetAccount([FromQuery] PagingRequest request) { int brandId = Convert.ToInt32(User.FindFirst("BrandId")?.Value != "" ? User.FindFirst("BrandId")?.Value : "0"); int role = Convert.ToInt32(User.FindFirst(ClaimTypes.Role)?.Value != "" ? User.FindFirst(ClaimTypes.Role)?.Value : "0"); if (role == 0) { brandId = 0; } var rs = await _accountService.GetAccount(request, brandId); return(Ok(rs)); }
public async Task GetAccount_Valid() { // Act var account = await _accountsService.GetAccount(Guid.Parse("bdca4f88-5868-4998-b5b1-6d7b77918c9b")); // Assert Assert.IsNotNull(account); Assert.IsInstanceOf <CustomerAccountDetailVm>(account); Assert.AreEqual(account.Address, _stubAccounts[0].Address); Assert.AreEqual(account.CanPurchase, _stubAccounts[0].CanPurchase); Assert.AreEqual(account.DOB, _stubAccounts[0].DOB); Assert.AreEqual(account.Email, _stubAccounts[0].Email); Assert.AreEqual(account.FirstName, _stubAccounts[0].FirstName); Assert.AreEqual(account.LastName, _stubAccounts[0].LastName); Assert.AreEqual(account.Id, _stubAccounts[0].Id); Assert.AreEqual(account.IsActive, _stubAccounts[0].IsActive); Assert.AreEqual(account.IsDeleteRequested, _stubAccounts[0].IsDeleteRequested); Assert.AreEqual(account.LoggedOnAt, _stubAccounts[0].LoggedOnAt); Assert.AreEqual(account.PhoneNumber, _stubAccounts[0].PhoneNumber); Assert.AreEqual(account.Postcode, _stubAccounts[0].Postcode); }
public async Task <ActionResult> Index() { var vm = new ActivityViewModel(); var account = await _accountsService.GetAccount(User); if (account == null) { vm.Transactions = new List <Transaction>(); } else { vm.Transactions = await _transactionsService.GetTransactions(account.Id); } return(View(vm)); }
public async Task <IActionResult> Details(Guid id) { string lowellReference = ApplicationSessionState.GetLowellReferenceFromSurrogate(id); Account account = await _accountsService.GetAccount(LoggedInUserId, lowellReference); MyAccountsDetailVm vm = _mapper.Map <Account, MyAccountsDetailVm>(account); vm.LoggedInUserId = LoggedInUserId; vm.LoggedInLowellRef = ApplicationSessionState.GetLoggedInLowellRef(); vm.LowellReferenceSurrogateKey = id; _gtmService.RaiseAccountDetailsViewedEvent(vm, LoggedInUserId, "Regular Account"); await _webActivityService.LogAccountDetailsViewed(vm.AccountReferenceText, LoggedInUserId); return(View(vm)); }
public async Task <IActionResult> GetAccount(Guid accountId) { _logger.LogInformation("Getting all custome account with id: " + accountId); if (accountId == null || accountId == Guid.Empty) { _logger.LogError("Failed to get account due to invalid or no account id"); throw new ArgumentNullException(nameof(accountId)); } var account = await _accountsService.GetAccount(accountId); if (account != null) { _logger.LogInformation("Successfully got account with account id: " + accountId); return(Ok(account)); } _logger.LogError("Failed to get account with account id: " + accountId); return(new StatusCodeResult(StatusCodes.Status500InternalServerError)); }
private bool IsReadingDuplicate(MeterReading reading) { var account = _AccountsService.GetAccount(reading.AccountId); var readings = _MetersRepository.GetMeterReadingsByAccount(account); if (null != readings) { foreach (var accountReading in readings) { if (accountReading.Reading == reading.Reading && accountReading.Recorded.Equals(reading.Recorded)) { return(true); } } } return(false); }
protected override async void OnPublished(object data) { if (isOpen) { return; } IsBusy = true; if (Messages != null && Messages.Any()) { ClearMessages(); } accountViewModel.Dispatcher = ViewModelContext.UiDispatcher; symbolsViewModel.Dispatcher = ViewModelContext.UiDispatcher; tradeViewModel.Dispatcher = ViewModelContext.UiDispatcher; ordersViewModel.Dispatcher = ViewModelContext.UiDispatcher; Account = new Account(new Interface.AccountInfo { User = new Interface.User() }); userAccount = accountsService.GetAccount(Title); if (userAccount != null && userAccount.Preferences != null) { if (!string.IsNullOrWhiteSpace(userAccount.ApiKey)) { Account.ApiKey = userAccount.ApiKey; Account.ApiSecret = userAccount.ApiSecret; } } SymbolsViewModel.SetAccount(userAccount); AccountViewModel.SetAccount(account); isOpen = true; IsBusy = false; }
public async Task <GetAccountResult> Handle(GetAccountQuery request, CancellationToken cancellationToken) { var validationResult = await _validator.ValidateAsync(request); if (!validationResult.IsValid()) { throw new ArgumentException("The following parameters have failed validation", validationResult.ValidationDictionary.Select(c => c.Key).Aggregate((item1, item2) => item1 + ", " + item2)); } var result = await _service.GetAccount(request.Id); if (result == null) { throw new EntityNotFoundException <Domain.Entities.Account>(); } return(new GetAccountResult { Account = result }); }
public ActionResult GetPMReport(int id, int year) { try { XLWorkbook Report = ReportGenerator.CreatePMReport(id, year); MemoryStream excelStream = new MemoryStream(); Report.SaveAs(excelStream); excelStream.Position = 0; AccountsModel account = Account.GetAccount(id); string filename = "KraReport_" + account.Name + "_" + year.ToString() + ".xlsx"; return(File(excelStream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", filename)); } catch (Exception ex) { logger.Error(ex.InnerException); logger.Error(ex.Message); logger.Error(ex.Source); return(View("Something Went Wrong")); } }
public ActionResult <AccountDTO> GetAccount(int accountId) { return(accountsService.GetAccount(accountId)); }
public static Task <Account> GetAccount(this IAccountsService accountsService, ClaimsPrincipal user) { var userId = user.GetUserId(); return(accountsService.GetAccount(AccountIdentification.ByGlobalUserId(userId))); }
public async Task <IActionResult> Transactions( TransactionsVm transactionsVm, int pageNumber = 1) { var value = RouteData.Values["id"]; if (value == null) { return(RedirectToAction("Index", "MyAccounts")); } Guid.TryParse(value.ToString(), out var id); if (!ModelState.IsValid) { return(View(transactionsVm)); } string lowellReference = ApplicationSessionState.GetLowellReferenceFromSurrogate(id); if (string.IsNullOrEmpty(lowellReference)) { throw new Exception("No lowell reference found in cache"); } Account account = ApplicationSessionState.GetAccount(lowellReference); if (account == null) { account = await _accountsService.GetAccount(LoggedInUserId, lowellReference); ApplicationSessionState.SaveAccount(account, lowellReference); } List <Transaction> transactions = ApplicationSessionState.GetTransactions(lowellReference); if (transactions == null) { transactions = await _transactionsService.GetTransactions(account.AccountReference); ApplicationSessionState.SaveTransactions(transactions, lowellReference); } if (transactions == null) { transactions = new List <Transaction>(); } transactionsVm.AccountName = account.OriginalCompany; transactionsVm.AccountBalance = account.OutstandingBalance; transactionsVm.AccountReference = account.AccountReference; _gtmService.RaiseTransactionsViewedEvent(transactionsVm, LoggedInUserId, "Regular Account"); await _webActivityService.LogAllTransactionsViewed(transactionsVm.AccountReference, LoggedInUserId); if (transactionsVm.FilterTransactions.DateFrom != null) { transactions = transactions.Where(x => x.Date >= transactionsVm.FilterTransactions.DateFrom).ToList(); } if (transactionsVm.FilterTransactions.DateTo != null) { transactions = transactions.Where(x => x.Date <= transactionsVm.FilterTransactions.DateTo).ToList(); } if (!string.IsNullOrEmpty(transactionsVm.FilterTransactions.KeyWord)) { transactions = transactions.Where(x => x.Description.ToLower().Contains(transactionsVm.FilterTransactions.KeyWord.ToLower())).ToList(); } transactions = transactions.OrderByDescending(x => x.Date).ToList(); if (!transactions.Any()) { transactionsVm.FilterTransactions.DateMessage = "No Results Found"; } transactionsVm.PagedList = _mapper.Map <List <Transaction>, List <TransactionVm> >(transactions).ToPagedList(pageNumber, _pageSize); transactionsVm.LoggedInUserID = LoggedInUserId; transactionsVm.LoggedInLowellRef = ApplicationSessionState.GetLoggedInLowellRef(); return(View(transactionsVm)); }
public async Task <PaymentOptionsVm> Build(IUserIdentity loggedInUser, IApplicationSessionState applicationSessionState, Guid lowellReferenceSurrogateKey, string caseflowUserId) { string lowellReference = applicationSessionState.GetLowellReferenceFromSurrogate(lowellReferenceSurrogateKey); AccountReferenceDto accountReferenceDto = new AccountReferenceDto() { LowellReference = lowellReference }; PaymentOptionsDto paymentOptionsDto = await _apiGatewayProxy.GetPaymentOptions(accountReferenceDto); IncomeAndExpenditureApiModel incomeAndExpenditureDto = await _apiGatewayProxy.GetIncomeAndExpenditure(lowellReference); List <AccountSummary> accounts; if (caseflowUserId != null) { accounts = await _accountsService.GetAccounts(caseflowUserId); } else { accounts = await _accountsService.GetMyAccountsSummary(lowellReference); } var workingAccounts = accounts.Count(a => !a.AccountStatusIsClosed); if (workingAccounts == 0) { workingAccounts = 1; } var accountDetails = await _accountsService.GetAccount(caseflowUserId, lowellReference); string[] planMessages = accountDetails.PlanMessages; var paymentOptionsVm = new PaymentOptionsVm() { OutstandingBalance = paymentOptionsDto.OutstandingBalance, LowellReference = paymentOptionsDto.LowellReference, ClientName = paymentOptionsDto.ClientName, ExcludedAccountMessage = paymentOptionsDto.ExcludedAccountMessage, PlanInPlace = paymentOptionsDto.PlanInPlace, PlanIsDirectDebit = paymentOptionsDto.PaymentPlanIsDirectDebit, WithLowellSolicitors = paymentOptionsDto.WithLowellSolicitors, PaymentOptions = new List <PaymentOptionsSelectionsVm>(), DiscountPercentage = paymentOptionsDto.DiscountPercentage, DiscountAmount = paymentOptionsDto.DiscountAmount, DiscountExpiryDate = paymentOptionsDto.DiscountExpiryDate, DiscountedBalance = paymentOptionsDto.DiscountedBalance, DiscountBalanceAvailable = paymentOptionsDto.DiscountBalanceAvailable, ProposedDiscountedBalanceIfAccepted = paymentOptionsDto.ProposedDiscountedBalanceIfAccepted, DiscountedBalancePreviouslyAccepted = paymentOptionsDto.DiscountedBalancePreviouslyAccepted, ArrearsMessage = _arrearsDescriptionProcess.DeriveArrearsDetail(paymentOptionsDto.PaymentPlanArrearsAmount, paymentOptionsDto.PaymentPlanIsAutomated), StandingOrder = paymentOptionsDto.StandingOrder, StandingOrderMessage = paymentOptionsDto.StandingOrderMessage, VerifoneTransactionGuid = $"{paymentOptionsDto.LowellReference}_{Guid.NewGuid()}", DiscountAccepted = paymentOptionsDto.DiscountedBalancePreviouslyAccepted, PlanMessage = planMessages != null && planMessages.Length > 0? planMessages[0]:string.Empty }; if (loggedInUser.IsLoggedInUser) { paymentOptionsVm.DirectDebitEmailAddress = loggedInUser.EmailAddress; } else { paymentOptionsVm.DirectDebitIsEmailAddressFieldVisible = true; } // Logged in user has accept T&C defaulted and will be hidden. // Anon user has tick box displayed. Must be ticked. if (loggedInUser.IsLoggedInUser) { paymentOptionsVm.AcceptTermsAndConditions = true; } else { paymentOptionsVm.IsAcceptTermsAndConditionsFieldVisible = true; } // Work out amount that needs to be paid to clear balance if (paymentOptionsVm.DiscountedBalancePreviouslyAccepted) { paymentOptionsVm.FullPaymentBalance = paymentOptionsVm.DiscountedBalance; } else { paymentOptionsVm.FullPaymentBalance = paymentOptionsVm.OutstandingBalance; } // Customer has a plan but it isn't direct debit. // Used to display a message informing customer that they can change to a DD online. if (paymentOptionsDto.PlanInPlace && !paymentOptionsDto.PaymentPlanIsDirectDebit) { paymentOptionsVm.HasNonDirectDebitPlanInPlace = true; } if (paymentOptionsDto.WithLowellSolicitors) { paymentOptionsVm.LowellSolicitorsRedirectLink = _portalSetting.SolicitorsRedirectDataProtectionUrl; } // Shared list of options for partial / full paymentOptionsVm.SourceOfFunds = BuildSourceOfFundsSelections(paymentOptionsDto); // Direct Debit paymentOptionsVm.DirectDebitFrequency = BuildFrequencyList(paymentOptionsDto.DirectDebitFrequencies); paymentOptionsVm.DirectDebitStartDateEarliest = paymentOptionsDto.DirectDebitStartDateEarliest; paymentOptionsVm.DirectDebitStartDateLatest = paymentOptionsDto.DirectDebitStartDateLatest; // TODO: Wrap the code below in a strategy pattern if (paymentOptionsDto.CanMakeFullPayment) { paymentOptionsVm.PaymentOptions.Add(new PaymentOptionsSelectionsVm() { DisplayedText = "Card payment (Pay in Full)", Value = PaymentOptionsSelectionsVm.Values.FullPayment, DataFormValue = PaymentOptionsSelectionsVm.Values.FullPayment }); } if (paymentOptionsDto.CanMakePartialPayment) { paymentOptionsVm.PaymentOptions.Add(new PaymentOptionsSelectionsVm() { DisplayedText = "Card payment (Partial amount)", Value = PaymentOptionsSelectionsVm.Values.PartialPayment, DataFormValue = PaymentOptionsSelectionsVm.Values.PartialPayment, ClassValue = "js-hide-option" // script hides this }); } if (paymentOptionsDto.CanSetupDirectDebit) { paymentOptionsVm.PaymentOptions.Add(new PaymentOptionsSelectionsVm() { DisplayedText = "Direct Debit plan", Value = PaymentOptionsSelectionsVm.Values.DirectDebit, DataFormValue = PaymentOptionsSelectionsVm.Values.DirectDebit }); } // Only add 'please select' if there are options // Required because view checks for availability of payment options if (paymentOptionsVm.PaymentOptions.Count > 0) { paymentOptionsVm.PaymentOptions.Insert(0, new PaymentOptionsSelectionsVm() { DisplayedText = "Please Select", Value = PaymentOptionsSelectionsVm.Values.PleaseSelect, DataFormValue = PaymentOptionsSelectionsVm.Values.PleaseSelect }); } paymentOptionsVm.LowellReferenceSurrogate = lowellReferenceSurrogateKey; paymentOptionsVm.IandENotAvailable = incomeAndExpenditureDto == null; paymentOptionsVm.IandELessThanOrIs12MonthsOld = (incomeAndExpenditureDto != null && incomeAndExpenditureDto.Created.AddMonths(12).Date >= DateTime.Now.Date); paymentOptionsVm.AverageMonthlyPayment = _portalSetting.AverageMonthlyPaymentAmount; paymentOptionsVm.MonthlyDisposableIncome = (incomeAndExpenditureDto == null ? 0 : (incomeAndExpenditureDto.DisposableIncome * (_portalSetting.MonthlyDisposableIncomePlanSetupPercentage / 100))); paymentOptionsVm.AccountCount = workingAccounts; paymentOptionsVm.MonthlyDisposableIncomePerAccount = paymentOptionsVm.MonthlyDisposableIncome / workingAccounts; return(paymentOptionsVm); }
private async Task <int?> GetReservationLimit(long accountId) { var account = await _accountService.GetAccount(accountId); return(account.ReservationLimit); }
public async Task <PayPalOrder> CreatePendingOrder(Guid accountId, decimal amount) { // TODO: Make this range configurable. if (amount <= 0 || amount > 500) { throw new Exception("Invalid amount."); } _logger.LogInformation("Creating pending paypal order for {AccountId} for {Amount}", accountId, amount); var account = await _accountsService.GetAccount(AccountIdentification.ById(accountId)); account.NotNull(); var potentialOrderId = Guid.NewGuid(); string paypalOrderId; { var client = _payPalClientProvider.BuildHttpClient(); var request = new OrdersCreateRequest(); request.Prefer("return=representation"); request.RequestBody(new OrderRequest { CheckoutPaymentIntent = "CAPTURE", PurchaseUnits = new List <PurchaseUnitRequest> { new PurchaseUnitRequest { ReferenceId = potentialOrderId.ToString(), AmountWithBreakdown = new AmountWithBreakdown { Value = amount.ToString(CultureInfo.InvariantCulture), CurrencyCode = "USD" } } } }); var response = await client.Execute(request); if (response.StatusCode != HttpStatusCode.Created) { _logger.LogError("Invalid status code from PayPal order create: status: {Status} response: {Response}", response.StatusCode, SerializePayPalType(response.Result <object>())); throw new Exception("Invalid PayPal response"); } paypalOrderId = response.Result <Order>().Id; } // Great, we created a PayPal order, let's add the record into the database. using (var con = new ConScope(_dataService)) { var pendingOrder = new PayPalOrder { Id = potentialOrderId, OrderStatus = PayPalOrderStatus.Pending, PayPalOrderId = paypalOrderId, AccountId = account.Id, Amount = amount }; await con.Connection.InsertAsync(pendingOrder); return(pendingOrder); } }
public AccountModel GetAccount(int accountId) { return(_accountsService.GetAccount(accountId)?.ToModel()); }
public void Can_Create_Delete_Account() { var servicePackages = _lookupService.GetServicePackages(); var contactTypes = _lookupService.GetContactTypes().ToList(); var contactMethods = _lookupService.GetContactMethods().ToList(); var paymentMethods = _lookupService.GetPaymentMethods().ToList(); var nvralertTypes = _lookupService.GetNvrAlertTypes().ToList(); var eventGroups = _lookupService.GetEventGroups().ToList(); var analyticAlgorithms = _lookupService.GetAnalyticAlgorithmTypes().ToList(); //step 1 - create account var accountDto = new AccountDto { AccountNumber = "123456789", Name = "Test_Account", ServicePackageId = servicePackages.ToList().SingleOrDefault(sp => sp.Name == "Silver").ServicePackageId, WebSiteURL = "http://2020Imaging.com", Email = "*****@*****.**", Description = "Test_Account_Description", TimeZoneId = _lookupService.GetTimeZones().First().TimeZoneId, AccountTypeId = _lookupService.GetAccountTypes().Single(at => at.AccoutTypeId == 2).AccoutTypeId, AccountBilling = null, }; var accountId = _accountService.AddAccount(accountDto); Assert.IsTrue(accountId > 0); var getAccount = _accountService.GetAccount(accountId); Assert.IsNotNull(getAccount); // step 2 - create person var personDto = new PersonDto { Title = "Msr.", FirstName = "Victor", LastName = "Lungu", JobTitle = "WPF Developer", Password = "******", PrimaryAccountAdministratorPassword = "******", }; var preferedContact1 = new PersonContactTypeDto { ContactTypeId = contactTypes[0].ContactTypeId }; var preferedContact2 = new PersonContactTypeDto { ContactTypeId = contactTypes[1].ContactTypeId }; personDto.PreferedContactTypes = new List <PersonContactTypeDto> { preferedContact1, preferedContact2 }; var savedPerson = _accountService.SaveAccountPerson(personDto, getAccount.AccountId); Assert.IsNotNull(savedPerson); // step 3 - create contact var contactDto = new ContactDto { TelephoneNumber = "37379604494", EmailAddress = "*****@*****.**", MobileNumber = "37379604494", LyncName = "Lync Name", FaxNumber = "37379604494", }; var preferedContatMethod1 = new PreferedContatMethodDto { ContactMethodId = contactMethods[0].ContactMethodId }; var preferedContatMethod2 = new PreferedContatMethodDto { ContactMethodId = contactMethods[1].ContactMethodId }; contactDto.PreferedContatMethods.Add(preferedContatMethod1); contactDto.PreferedContatMethods.Add(preferedContatMethod2); var savedContact = _accountService.SaveAccountContact(contactDto, savedPerson.PersonId); Assert.IsNotNull(savedContact); //step 4 - create accounnt address var addressDto = new AddressDto { AddressNumber = 3343, AddressTypeCode = 22, City = "Chisinau", Country = "Moldova, Republic of", County = "municipiiul Chisinau", Fax = "37379604494", Latitude = 100.22233, Line1 = "str. Iazului 6", Line2 = "ap. 53", Longitude = 444332, Name = "Main Address", PostOfficeBox = "443332", PostalCode = "PC5543" }; var accountAddress = _accountService.SaveAccountAddress(addressDto, accountId); Assert.IsNotNull(accountAddress); //step 5 Billing address var billingAddress = new AddressDto { AddressNumber = 3343, AddressTypeCode = 22, City = "Chisinau", Country = "Moldova, Republic of", County = "municipiiul Chisinau", Fax = "37379604494", Latitude = 100.22233, Line1 = "str. Iazului 6", Line2 = "ap. 53", Longitude = 444332, Name = "Main Address", PostOfficeBox = "443332", PostalCode = "PC5543" }; var accountBilling = new AccountBillingDto { PaymentMethodId = paymentMethods.First().PaymentMethodId, Address = billingAddress }; var accountBillig = _accountService.SaveAccountBilling(accountBilling, accountId); Assert.IsNotNull(accountBillig); var accountNvrAlertTypeDto1 = new AccountNvrAlertTypeDto { NvrAlertTypeId = nvralertTypes.First().NvrAlertTypeId }; var accountNvrAlertTypeDto2 = new AccountNvrAlertTypeDto { NvrAlertTypeId = nvralertTypes.Last().NvrAlertTypeId }; _accountService.SaveAccountNvrAlertType( new List <AccountNvrAlertTypeDto>() { accountNvrAlertTypeDto1, accountNvrAlertTypeDto2 }, accountId); var accountAlarmPanel1 = new AccountAlarmPanelDto() { EventGroupId = eventGroups.First().EventGroupId }; var accountAlarmPanel2 = new AccountAlarmPanelDto() { EventGroupId = eventGroups.Last().EventGroupId }; _accountService.SaveAccountAlarmPanel( new List <AccountAlarmPanelDto>() { accountAlarmPanel1, accountAlarmPanel2 }, accountId); var analyticAlgorithm1 = new AccountAnalyticsAlgorithmTypeDto() { AnalyticsAlgorithTypeId = analyticAlgorithms.First().AnalyticAlgorithmId }; var analyticAlgorithm2 = new AccountAnalyticsAlgorithmTypeDto() { AnalyticsAlgorithTypeId = analyticAlgorithms.Last().AnalyticAlgorithmId }; _accountService.SaveAccountAnalyticsAlgorithms( new List <AccountAnalyticsAlgorithmTypeDto>() { analyticAlgorithm1, analyticAlgorithm2 }, accountId); var deleteContact = _accountService.DeleteContact(savedContact.ContactId); Assert.IsTrue(deleteContact); _accountService.DeletePerson(savedPerson.PersonId); var accountDeleted = _accountService.DeleteAccount(getAccount.AccountId); Assert.IsTrue(accountDeleted); }
public ActionResult GetAccountById(string id) { return(RequireAuth(_accountService.GetAccount(id))); }