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);
}
