private ZcashLikePaymentMethodViewModel GetZcashLikePaymentMethodViewModel( IEnumerable <ZcashSupportedPaymentMethod> Zcash, string cryptoCode, IPaymentFilter excludeFilters, GetAccountsResponse accountsResponse) { var settings = Zcash.SingleOrDefault(method => method.CryptoCode == cryptoCode); _ZcashRpcProvider.Summaries.TryGetValue(cryptoCode, out var summary); _ZcashLikeConfiguration.ZcashLikeConfigurationItems.TryGetValue(cryptoCode, out var configurationItem); var fileAddress = Path.Combine(configurationItem.WalletDirectory, "wallet"); var accounts = accountsResponse?.SubaddressAccounts?.Select(account => new SelectListItem( $"{account.AccountIndex} - {(string.IsNullOrEmpty(account.Label) ? "No label" : account.Label)}", account.AccountIndex.ToString(CultureInfo.InvariantCulture))); return(new ZcashLikePaymentMethodViewModel() { WalletFileFound = System.IO.File.Exists(fileAddress), Enabled = settings != null && !excludeFilters.Match(new PaymentMethodId(cryptoCode, ZcashPaymentType.Instance)), Summary = summary, CryptoCode = cryptoCode, AccountIndex = settings?.AccountIndex ?? accountsResponse?.SubaddressAccounts?.FirstOrDefault()?.AccountIndex ?? 0, Accounts = accounts == null ? null : new SelectList(accounts, nameof(SelectListItem.Value), nameof(SelectListItem.Text)) }); }
public void HandleGetAccountsResponse(JamPacket packet) { if (packet.Header.DataType != GetAccountsResponse.DATA_TYPE) { return; } App.Current.Dispatcher.Invoke(() => { MainWindow main = App.Current.MainWindow as MainWindow; GetAccountsResponse response = new GetAccountsResponse(packet.Data, main.Client.Serializer); foreach (Tuple <Account, bool> tuple in response.Accounts) { Account account = tuple.Item1; bool online = tuple.Item2; if (account.AccountID != LoggedInAccount.Account.AccountID) { DisplayableAccount displayableAccount = new DisplayableAccount(account, online); Accounts.Add(displayableAccount); } } }); }
public ReIndexTagsResponse ReIndexTags(ReIndexTagsRequest request) { var response = new GetAccountsResponse(); var totalTagsIndexed = 0; if (request.AccountId != 0) { var arl = new List <AccountViewModel>(); arl.Add(new AccountViewModel() { AccountID = request.AccountId }); response.Accounts = arl; } else { response = accountService.GetAccounts(); } foreach (int accountId in response.Accounts.Select(a => a.AccountID)) { Logger.Current.Verbose("Request to reindex the tags for account id:" + accountId); indexingService.SetupTagIndex(accountId); IEnumerable <Tag> documents = tagRepository.FindAll(accountId).ToList(); int count = indexingService.ReIndexAllTags(documents); totalTagsIndexed += count; } return(new ReIndexTagsResponse() { IndexedTags = totalTagsIndexed }); }
public ActionResult <GetAccountsResponse> GetAccounts([FromHeader] string client, [FromRoute] string cpf) { GetAccountsResponse response = new GetAccountsResponse(); string responseCode = $"GET_ACCOUNTS_{client}_{cpf}"; try { var factory = WalletFactory.Instance.GetAccount(_configuration, true); var accounts = factory.GetAccounts(client, cpf); if (accounts.Count == 0) { response.StatusCode = "404"; response.Messages.Add(ResponseMessage.Create(responseCode, "no account found for this client.")); return(NotFound(response)); } response.StatusCode = "200"; accounts.ForEach(account => response.Data.Add(account.Adapt())); return(Ok(response)); } catch (Exception ex) { response.StatusCode = "500"; response.Messages.Add(ResponseMessage.Create(ex, responseCode)); return(StatusCode(500, response)); } }
public GetAccountsResponse GetAccounts(GetAccountsRequest request, IAuthContext authContext) { var accountRepo = _unitOfWork.GetRepository <Account>(); var accounts = accountRepo.GetAsyncQueryable(x => x.UserId.ToString() == authContext.UserId, w => w.AccountIdentifications).Result.ToList(); GetAccountsResponse response = new GetAccountsResponse(); response.Items = new List <GetAccountsResponseItem>(); foreach (Account acc in accounts) { var account = new GetAccountsResponseItem() { AccountId = acc.Id.ToString(), AccountType = AccountType.GetInstance(acc.AccountType).Text, CurrencyType = CurrencyType.GetInstance(acc.CurrencyType).Text, Name = acc.Name, ProviderAccountId = acc.ProviderAccountId, ProviderName = Provider.GetInstance(acc.ProviderId).Text }; foreach (AccountIdentification ai in acc.AccountIdentifications) { account.AccountIdentification.Add(AccountIdentificationType.GetInstance(ai.AccountIdentificationTypeId).Text + ": " + ai.Identification); } response.Items.Add(account); } return(response); }
public List <Account> GetAccounts() { var response = GetAccountsResponse.GetAccounts(_tokenManager.GetAuthToken()); return(response.Accounts.Select(a => new Account { Name = a.m_number }).ToList()); }
public static WebResponse <IEnumerable <AccountModel> > AsWebResponse(this GetAccountsResponse response) { var result = new WebResponse <IEnumerable <AccountModel> >(response.Accounts) { Data = response.Accounts, Errors = response.Errors, Message = response.Message, Success = response.Success }; return(result); }
public void GetAllAccounts_ToGetAllTheAccounts_Succeed() { var mockAccounts = AccountMockData.GetMockAccounts(mockRepository, 10).ToList(); // mockAccountRepository.Setup(cr => cr.FindAll(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<byte>())).Returns(mockAccounts); GetAccountsResponse response = accountService.GetAllAccounts(new GetAccountsRequest() { Query = "", Limit = 10, PageNumber = 1 }); var accounts = response.Accounts; mockRepository.VerifyAll(); Assert.AreEqual(mockAccounts.Count(), accounts.Count()); Assert.AreEqual(null, response.Exception); }
public async Task <IActionResult> GetAllAccountsAsync(string continuationToken, int limit, string role) { var result = await _accountService.GetAccounts(continuationToken, limit, role); string nextUri = null; if (!string.IsNullOrWhiteSpace(result.ContinuationToken)) { nextUri = $"api/accounts?continuationToken={WebUtility.UrlEncode(result.ContinuationToken)}&limit={limit}&role={role}"; } var response = new GetAccountsResponse { NextUri = nextUri, Accounts = result.Accounts }; return(Ok(response)); }
public async Task <IActionResult> GetAccountsByUserId(string userId) { try { var queryResult = await _mediator.Send(new GetUserAccountsQuery { UserId = userId }); var returnModel = new GetAccountsResponse { HashedAccountIds = queryResult.HashedAccountIds }; return(Ok(returnModel)); } catch (Exception e) { _logger.LogError(e, "Error getting account by id"); return(BadRequest()); } }
public override Task <GetAccountsResponse> GetAccounts(GetAccountsRequest request, ServerCallContext context) { var res = new GetAccountsResponse(); res.Accounts.AddRange( _accountsService.GetClientAccounts(request.ClientId).Select(a => new GetAccountsResponse.Types.Account { AccountId = a.AccountId, Balance = DecimalValue.FromDecimal(a.Balance), Number = a.Number, Name = a.Name, Description = a.Description, OpenDate = Timestamp.FromDateTime(a.OpenDate.ToUniversalTime()) } )); return(Task.FromResult(res)); }
public async Task <GetAccountsResponse> GetAccountsAsync() { try { var result = await this.accountDataGateway.GetAccounts(); var response = new GetAccountsResponse(); if (result.ToList() != null) { response.Accounts = result; response.Success = true; response.Message = "Successfully Retrieved Accounts"; } return(response); } catch (Exception ex) { throw new AccountServiceException(ex.Message.ToString(), ex.InnerException); } }
private static void GetRegisteredAccounts(JamServerConnection serverConnection) { List <Tuple <Account, bool> > accounts = new List <Tuple <Account, bool> >(); try { foreach (Account account in AccountFactory.Accounts) { bool online = serverConnection.Server.GetConnection(account.AccountID) != null; accounts.Add(new Tuple <Account, bool>(account, online)); } } catch (EntityException) { serverConnection.Server.Dispose(); return; } GetAccountsResponse response = new GetAccountsResponse(accounts, serverConnection.Serializer); JamPacket responsePacket = new JamPacket(Guid.Empty, Guid.Empty, GetAccountsResponse.DATA_TYPE, response.GetBytes()); serverConnection.Send(responsePacket); }
public ActionResult <GetAccountsResponse> GetAccounts([FromQuery] GetAccountsRequest request) { GetAccountsResponse response = _accountDataService.GetAccounts(request, _authContext); return(Ok(response)); }
public async Task <List <GetPendingApplicationEmailDataQueryResult.EmailData> > GetEmailDataFromAccountsResponse(GetAccountsResponse getAccountsResponse) { var emailDataList = new List <GetPendingApplicationEmailDataQueryResult.EmailData>(); var getApplicationsResponse = await _levyTransferMatchingService.GetApplications(new GetApplicationsRequest { ApplicationStatusFilter = PledgeStatus.Pending }); var employerAccountIds = getApplicationsResponse.Applications.Select(x => x.SenderEmployerAccountId).Distinct(); foreach (var employerAccountId in employerAccountIds) { var employerName = getApplicationsResponse.Applications.First(x => x.SenderEmployerAccountId == employerAccountId).SenderEmployerAccountName; var applicationCount = getApplicationsResponse.Applications.Count(x => x.SenderEmployerAccountId == employerAccountId); List <TeamMember> users = await _accountsService.GetAccountUsers(employerAccountId); users = users.Where(x => (x.Role == "Owner" || x.Role == "Transactor") && x.CanReceiveNotifications).ToList(); foreach (var user in users) { emailDataList.Add(new GetPendingApplicationEmailDataQueryResult.EmailData { RecipientEmailAddress = user.Email, EmployerName = employerName, NumberOfApplications = applicationCount, AccountId = employerAccountId }); } } return(emailDataList); }
public void GetAccounts() { GetAccountsResponse response = _api.GetAccounts(); Assert.IsTrue(response?.Accounts != null); }