private JsonResult GetDirect(int Height, int startHeight, int chainHeight)
{
List <int> blockHeights = new List <int>();
for (var x = startHeight; x < chainHeight; x++)
{
blockHeights.Add(x);
}
//fetch the transactions directly from the Blockchain
var args = new Dictionary <string, object>();
args.Add("blockHeights", blockHeights);
var blocks = RpcHelper.Request <BlockResp>("get_blocks_details_by_heights", args).blocks;
List <CachedTx> transactions = new List <CachedTx>();
foreach (var block in blocks)
{
foreach (var transaction in block.transactions)
{
var cachedTx = TransactionHelpers.MapTx(transaction);
//persist tx's to cache
if (cachedTx != null)
{
transactions.Add(cachedTx);
}
}
}
return(new JsonResult(JsonConvert.SerializeObject(transactions)));
}
public void OneTimeSetUp()
{
_network = CirrusNetwork.NetworksSelector.Testnet();
_transactionHelpers = new TransactionHelpers(_network);
ValidAddress = "tNuiVJiEhvbQgXu4P32S4TnAVEG3kgLnu8";
InvalidAddress = "CWNYqR11FFsbt14FVtmV1X3rPntoxGtYrR";
}
public async Task TestDomainEventsAreRegistered()
{
//Arrange
var aggregate = ServiceLocator.Current.GetInstance <EventAggregate>();
var module = ServiceLocator.Current.GetInstance <IExtractEventMetadataService>();
var command = await module.ExtractEventMetadata(new DateTime(2015, 7, 14));
using (var scope = TransactionHelpers.GetTransactionScope())
{
//Act
aggregate.ImportEvent(command);
var successEvent = aggregate.DomainEvents.FirstOrDefault();
//Assert
Assert.IsNotNull(successEvent);
Assert.IsTrue(successEvent is EventImported);
var importedEvent = successEvent as EventImported;
Assert.AreEqual(26, importedEvent.DealIds.Count());
Assert.AreEqual(26, importedEvent.PairIds.Count());
scope.Dispose();
}
}
public static async IAsyncEnumerable <ChangeAvoidanceSuggestionViewModel> GenerateSuggestionsAsync(
TransactionInfo transactionInfo, BitcoinAddress destination, Wallet wallet, [EnumeratorCancellation] CancellationToken cancellationToken)
{
Task <ChangeAvoidanceSuggestionViewModel?> bnbSuggestionTask = Task.Run(() =>
{
if (ChangelessTransactionCoinSelector.TryGetCoins(transactionInfo.Coins, transactionInfo.FeeRate, new TxOut(transactionInfo.Amount, destination), out IEnumerable <SmartCoin>?selection, cancellationToken))
{
BuildTransactionResult transaction = TransactionHelpers.BuildChangelessTransaction(
wallet,
destination,
transactionInfo.UserLabels,
transactionInfo.FeeRate,
selection,
tryToSign: false);
return(new ChangeAvoidanceSuggestionViewModel(
transactionInfo.Amount.ToDecimal(MoneyUnit.BTC),
transaction,
wallet.Synchronizer.UsdExchangeRate,
isOriginal: false));
}
return(null);
});
ChangeAvoidanceSuggestionViewModel?bnbSuggestion = await bnbSuggestionTask;
if (bnbSuggestion is not null)
{
yield return(bnbSuggestion);
}
}
public ActionResult Create(int?Id)
{
// Household Id
if (Id is null)
{
TempData.Add("Message", "Improper Id");
TempData.Add("MessageColour", "danger");
return(RedirectToAction("Index", "Household"));
}
var viewModel = new CreateTransactionViewModel()
{
HouseholdId = (int)Id,
Date = DateTime.Now
};
TransactionHelpers.SetDropDownLists(viewModel, Request);
if (TransactionHelpers.BankAccntOrCategoriesIsNull(viewModel, TempData))
{
return(RedirectToAction("Index", "Household"));
}
return(View(viewModel));
}
public static async IAsyncEnumerable <ChangeAvoidanceSuggestionViewModel> GenerateSuggestionsAsync(
TransactionInfo transactionInfo,
BitcoinAddress destination,
Wallet wallet,
[EnumeratorCancellation] CancellationToken cancellationToken)
{
var selections = ChangelessTransactionCoinSelector.GetAllStrategyResultsAsync(
transactionInfo.Coins,
transactionInfo.FeeRate,
new TxOut(transactionInfo.Amount, destination),
cancellationToken).ConfigureAwait(false);
await foreach (var selection in selections)
{
if (selection.Any())
{
BuildTransactionResult transaction = TransactionHelpers.BuildChangelessTransaction(
wallet,
destination,
transactionInfo.UserLabels,
transactionInfo.FeeRate,
selection,
tryToSign: false);
yield return(new ChangeAvoidanceSuggestionViewModel(
transactionInfo.Amount.ToDecimal(MoneyUnit.BTC),
transaction,
wallet.Synchronizer.UsdExchangeRate));
}
}
}
public JsonResult Index()
{
var rawTxs = RpcHelper.RequestJson <TxPoolResp>("f_on_transactions_pool_json", new Dictionary <string, object>()).result.transactions;
var txHashes = new List <string>();
foreach (var rawTx in rawTxs)
{
txHashes.Add(rawTx.hash);
}
var tx_args = new Dictionary <string, object>();
tx_args.Add("transactionHashes", txHashes.ToArray());
var txs = RpcHelper.Request <TxDetailResp>("get_transaction_details_by_hashes", tx_args);
List <CachedTx> transactions = new List <CachedTx>();
if (txs != null)
{
foreach (var rawTx in txs.transactions)
{
var memPoolTx = TransactionHelpers.MapTx(rawTx);
memPoolTx.height = 0;
transactions.Add(memPoolTx);
}
}
return(new JsonResult(JsonConvert.SerializeObject(transactions)));
}
private List <JournalEntryLine> GetGlEntries(FinancialBatch financialBatch, ref string debugLava, string DescriptionLava = "")
{
if (string.IsNullOrWhiteSpace(DescriptionLava))
{
DescriptionLava = "{{ Batch.Id }}: {{ Batch.Name }}";
}
var rockContext = new RockContext();
//
// Group/Sum Transactions by Account and Project since Project can come from Account or Transaction Details
//
List <RegistrationInstance> registrationLinks;
List <GroupMember> groupMemberLinks;
var batchTransactionsSummary = TransactionHelpers.GetTransactionSummary(financialBatch, rockContext, out registrationLinks, out groupMemberLinks);
//
// Get the Dimensions from the Account since the Transaction Details have been Grouped already
//
var customDimensions = TransactionHelpers.GetCustomDimensions();
var batchSummary = new List <GLBatchTotals>();
foreach (var summary in batchTransactionsSummary)
{
var account = new FinancialAccountService(rockContext).Get(summary.FinancialAccountId);
var customDimensionValues = new Dictionary <string, dynamic>();
account.LoadAttributes();
var mergeFieldObjects = new MergeFieldObjects
{
Account = account,
Batch = financialBatch,
Registrations = registrationLinks,
GroupMembers = groupMemberLinks,
Summary = summary,
CustomDimensions = customDimensions
};
Dictionary <string, object> mergeFields = TransactionHelpers.GetMergeFieldsAndDimensions(ref debugLava, customDimensionValues, mergeFieldObjects);
var batchSummaryItem = new GLBatchTotals()
{
Amount = summary.Amount,
CreditAccount = account.GetAttributeValue("rocks.kfs.Intacct.ACCOUNTNO"),
DebitAccount = account.GetAttributeValue("rocks.kfs.Intacct.DEBITACCOUNTNO"),
TransactionFeeAmount = summary.TransactionFeeAmount,
TransactionFeeAccount = summary.TransactionFeeAccount,
Class = account.GetAttributeValue("rocks.kfs.Intacct.CLASSID"),
Department = account.GetAttributeValue("rocks.kfs.Intacct.DEPARTMENT"),
Location = account.GetAttributeValue("rocks.kfs.Intacct.LOCATION"),
Project = summary.Project,
Description = DescriptionLava.ResolveMergeFields(mergeFields),
CustomDimensions = customDimensionValues,
ProcessTransactionFees = summary.ProcessTransactionFees
};
batchSummary.Add(batchSummaryItem);
}
return(GenerateLineItems(batchSummary));
}
public async Task <string> DeployContractAsync()
{
var transactionHelper = new TransactionHelpers();
var web3 = new Web3(publicNode);
return(await transactionHelper.DeployContract(privateKey, web3, account,
byteCode));
}
/// <summary>Registers the patient.</summary>
/// <param name="firstName">The first name.</param>
/// <param name="lastName">The last name.</param>
/// <param name="city">The city.</param>
/// <param name="state">The state.</param>
/// <param name="zip">The zip.</param>
/// <param name="phone">The phone.</param>
/// <param name="dob">The dob.</param>
/// <param name="gender">The gender.</param>
/// <param name="address1">The address1.</param>
/// <param name="address2">The address2.</param>
/// <returns>true if patient was registerd, false otherwise</returns>
public static bool RegisterPatient(string firstName, string lastName, string city, string state, int zip,
string phone, DateTime dob, Gender gender, string address1, string address2)
{
MySqlTransaction transaction = TransactionHelpers.BeginTransaction();
int userId = UserDAL.Register(firstName, lastName, city, state, zip, phone, dob, gender, address1, address2);
bool registrationSuccess = PatientDAL.Register(userId);
return(TransactionHelpers.CommitTransaction(transaction) && registrationSuccess);
}
public virtual async Task ShouldDeployStandardSchema()
{
var transactionHelper = new TransactionHelpers();
var web3 = await CreateNewWeb3Instance();
string contract = await
transactionHelper.DeployContract(web3, Account, _password,
WorkStandardSchemaByteCode, false);
}
public JsonResult Get(int height = 0)
{
//TODO: Update this to split get Tx's from Split BC cache
var sizeBlock = 1000;
var startHeight = height;
var endHeight = startHeight + 100;
if (startHeight < 1)
{
startHeight = 1;
}
//todo, we don't have to query the chain height every time this is requested
var chainHeight = RpcHelper.Request <GetHeightResp>("getheight").Height;
if (chainHeight == 0)
{
chainHeight = endHeight + 100;
}
if (endHeight > chainHeight)
{
endHeight = chainHeight;
}
List <int> dbSegments = new List <int>();
var segmentStart = Convert.ToInt32(Math.Floor((double)(startHeight / sizeBlock) * sizeBlock)) + 1;
dbSegments.Add(segmentStart);
if (startHeight + 100 > segmentStart + sizeBlock - 1)
{
dbSegments.Add(segmentStart + sizeBlock);
}
try
{
//TODO:... if we find a problem - ie: there are ANY tx's that don't return at least one Tx poer height, then we need to re-cache the DB file we're working with for this height...
//we need to ensure that there is at least one Tx per block
//should this be in a seperate "validation background job that's checking completed files - maybe to run once per day?
List <LightTx> transactions = new List <LightTx>();
foreach (var start in dbSegments)
{
var end = start + sizeBlock - 1;
using (var db = new LiteDatabase(string.Concat(AppContext.BaseDirectory, @"App_Data\", "transactions_", start, "-", end, ".db")))
{
var cachedtxs = db.GetCollection <CachedTx>("cached_txs");
var txs = cachedtxs.Find(x => x.height >= startHeight && x.height <= endHeight).Distinct().ToList();
transactions.AddRange(TransactionHelpers.MapTxs(txs));
}
}
return(new JsonResult(JsonConvert.SerializeObject(transactions)));
}
catch (Exception ex)
{
//todo: log and return client handlable exception
}
return(new JsonResult(""));
}
public async Task <string> DeployContractAsync()
{
var transactionHelper = new TransactionHelpers();
//var address = System.Configuration.ConfigurationManager.
return(await
transactionHelper.DeployContract(new Web3(), "0xbb7e97e5670d7475437943a1b314e661d7a9fa2a", "password",
"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"));
}
public override async Task <string> DeployContractAsync()
{
var transactionHelper = new TransactionHelpers();
var web3 = await CreateNewWeb3Instance();
var contract = await
transactionHelper.DeployContract(PrivateKey, WorkContractDefinition.ABI, web3, Account,
ByteCode, new[] { WorkStandardSchemaAddress });
return(contract);
}
public virtual async Task <string> ShouldDeployStandardSchema()
{
var transactionHelper = new TransactionHelpers();
var web3 = await CreateNewWeb3Instance();
var contract = await
transactionHelper.DeployContract(PrivateKey, web3, Account,
WorkStandardSchemaByteCode);
return(contract);
}
public virtual async Task <string> ShouldDeployRegistryFactory()
{
var transactionHelper = new TransactionHelpers();
var web3 = await CreateNewWeb3Instance();
var contract = await
transactionHelper.DeployContract(PrivateKey, web3, Account,
WorkFactoryService.BYTE_CODE);
return(contract);
}
/// <summary>Registers the administrator.</summary>
/// <param name="firstName">The first name.</param>
/// <param name="lastName">The last name.</param>
/// <param name="city">The city.</param>
/// <param name="state">The state.</param>
/// <param name="zip">The zip.</param>
/// <param name="phone">The phone.</param>
/// <param name="dob">The dob.</param>
/// <param name="gender">The gender.</param>
/// <param name="address1">The address1.</param>
/// <param name="address2">The address2.</param>
/// <param name="username">The username.</param>
/// <param name="password">The password.</param>
/// <returns>true if admin was registered, false otherwise</returns>
public static bool RegisterAdministrator(string firstName, string lastName, string city, string state, int zip,
string phone, DateTime dob, Gender gender, string address1, string address2, string username, string password)
{
MySqlTransaction transaction = TransactionHelpers.BeginTransaction();
int userId = UserDAL.Register(firstName, lastName, city, state, zip, phone, dob, gender, address1, address2);
bool accountRegistrationSuccess = AccountDAL.Register(username, password);
bool administratorRegistrationSuccess = AdministratorDAL.Register(userId, username);
bool registrationSuccess = accountRegistrationSuccess && administratorRegistrationSuccess;
return(TransactionHelpers.CommitTransaction(transaction) && registrationSuccess);
}
public override async Task <string> DeployContractAsync()
{
var transactionHelper = new TransactionHelpers();
var web3 = await CreateNewWeb3Instance();
var contract = await
transactionHelper.DeployContract(WorkContractDefinition.ABI, web3, Account, _password,
ByteCode, new[] { WorkStandardSchemaAddress });
Debug.WriteLine("Contract created: " + contract);
return(contract);
}
public ActionResult Edit(EditTransactionViewModel transactionViewModel)
{
if (!ModelState.IsValid)
{
TransactionHelpers.SetCategoryDropDownList(transactionViewModel, Request);
if (transactionViewModel.Categories is null)
{
TempData.Add("Message", "Error: Categories missing");
TempData.Add("MessageColour", "danger");
return(RedirectToAction("Index", "Household"));
}
return(View(transactionViewModel));
}
var url = $"{ProjectConstants.APIURL}/api/transaction/edit/{transactionViewModel.Id}";
var parameters = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("Title", transactionViewModel.Title),
new KeyValuePair <string, string>("Description", transactionViewModel.Description),
new KeyValuePair <string, string>("Amount", transactionViewModel.Amount.ToString()),
new KeyValuePair <string, string>("Date", transactionViewModel.Date.ToString()),
new KeyValuePair <string, string>("CategoryId", transactionViewModel.CategoryId.ToString()),
};
var encodedParameters = new FormUrlEncodedContent(parameters);
var response = HttpClientContext.httpClient.PostAsync(url, encodedParameters).Result;
if (response.IsSuccessStatusCode)
{
TempData.Add("Message", $"Transaction '{transactionViewModel.Title}' Edited!");
return(RedirectToAction("HouseholdTransactions", "Transaction", new { Id = transactionViewModel.HouseholdId }));
}
else
{
ErrorHelpers.HandleResponseErrors(response, TempData, ModelState);
TransactionHelpers.SetCategoryDropDownList(transactionViewModel, Request);
if (transactionViewModel.Categories is null)
{
TempData.Add("Message", "Error: Categories missing");
TempData.Add("MessageColour", "danger");
return(RedirectToAction("Index", "Household"));
}
return(View(transactionViewModel));
}
}
public async Task <string> RegisterDeployedContract(string address)
{
var web3 = CreateNewWeb3Instance();
var contractRegistryService = new RegistryService(web3, contractAddress);
var tx = await contractRegistryService.RegisterAsync(account,
address,
defaultGas);
var transactionHelper = new TransactionHelpers();
var receipt = await transactionHelper.GetTransactionReceipt(web3, tx);
return(tx);
}
public IActionResult PostTransaction([FromBody] TransactionForDisplay transaction)
{
var transactions = new List <TransactionForDisplay>();
if (transaction.TransactionId == null || transaction.TransactionId == Guid.Empty)
{
transaction.TransactionId = Guid.NewGuid();
}
if (transaction.AccountId == null)
{
transaction.AccountId = _accountRepo.GetAll().Single(a => a.Name.Equals(transaction.AccountName, StringComparison.CurrentCultureIgnoreCase)).AccountId;
}
transaction.SetAmount();
transaction.EnteredDate = DateTime.Now;
if (transaction.CategoryId.IsNullOrEmpty() && !string.IsNullOrWhiteSpace(transaction.CategoryName))
{
var category = _categoryRepo.GetAll().SingleOrDefault(c => (c.Name.Equals(transaction.CategoryName, StringComparison.CurrentCultureIgnoreCase)));
if (category == null)
{
category = new Category
{
CategoryId = Guid.NewGuid(),
Name = transaction.CategoryName,
Type = "Expenses"
};
_categoryRepo.Insert(category);
}
transaction.CategoryId = category.CategoryId;
}
var bankFeeTransactions = TransactionHelpers.GetBankFeeTransactions(transaction, _categoryRepo, _accountRepo);
transactions.Add(transaction);
transactions.AddRange(bankFeeTransactions);
foreach (var trx in transactions)
{
_transactionRepo.Insert(trx);
}
var accountBalances = _accountRepo.GetAccountBalances().Select(a => new { a.AccountId, a.CurrentBalance });
InvoiceForPosting invoice = null;
if (transaction.InvoiceId.HasValue)
{
invoice = _invoiceRepo.Get(transaction.InvoiceId.Value);
}
var vendor = _vendorRepo.GetAll().SingleOrDefault(v => v.Name == transaction.Vendor);
return(CreatedAtAction("PostTransaction", new { id = transaction.TransactionId }, new { transactions, accountBalances, invoice, vendor }));
}
public IActionResult PostAccount([FromBody] AccountForPosting account)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newAccount = new Account
{
AccountId = Guid.NewGuid(),
Name = account.Name,
Currency = account.Currency,
Vendor = account.Vendor,
AccountType = account.AccountType,
MortgagePayment = account.MortgagePayment,
MortgageType = account.MortgageType
};
_accountRepo.Insert(newAccount);
var category = TransactionHelpers.GetOrCreateCategory("Starting Balance", _categoryRepo);
var transaction = new TransactionForDisplay
{
TransactionId = Guid.NewGuid(),
AccountId = newAccount.AccountId,
Amount = account.StartingBalance,
TransactionDate = account.StartDate,
Vendor = "",
Description = "",
CategoryId = category.CategoryId,
CategoryName = category.Name,
EnteredDate = account.StartDate,
IsReconciled = true
};
_transactionRepo.Insert(transaction);
var model = new AccountWithTransactions
{
AccountId = newAccount.AccountId,
Name = newAccount.Name,
Transactions = new List <TransactionForDisplay>(new[] { transaction }),
CurrentBalance = account.StartingBalance
};
return(CreatedAtAction("PostAccount", new { id = newAccount.AccountId }, model));
}
public ActionResult Create(CreateTransactionViewModel transactionViewModel)
{
if (!ModelState.IsValid || transactionViewModel.BankAccountId is null || transactionViewModel.CategoryId is null)
{
TransactionHelpers.SetDropDownLists(transactionViewModel, Request);
if (TransactionHelpers.BankAccntOrCategoriesIsNull(transactionViewModel, TempData))
{
return(RedirectToAction("Index", "Household"));
}
return(View(transactionViewModel));
}
var url = $"{ProjectConstants.APIURL}/api/transaction/create/{transactionViewModel.BankAccountId}";
var parameters = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("Title", transactionViewModel.Title),
new KeyValuePair <string, string>("Description", transactionViewModel.Description),
new KeyValuePair <string, string>("Amount", transactionViewModel.Amount.ToString()),
new KeyValuePair <string, string>("Date", transactionViewModel.Date.ToString()),
new KeyValuePair <string, string>("CategoryId", transactionViewModel.CategoryId.ToString()),
};
var encodedParameters = new FormUrlEncodedContent(parameters);
var response = HttpClientContext.httpClient.PostAsync(url, encodedParameters).Result;
if (response.IsSuccessStatusCode)
{
TempData.Add("Message", "Transaction Created!");
return(RedirectToAction("HouseholdTransactions", "Transaction", new { Id = transactionViewModel.HouseholdId }));
}
else
{
TransactionHelpers.SetDropDownLists(transactionViewModel, Request);
if (TransactionHelpers.BankAccntOrCategoriesIsNull(transactionViewModel, TempData))
{
return(RedirectToAction("Index", "Household"));
}
ErrorHelpers.HandleResponseErrors(response, TempData, ModelState);
return(View(transactionViewModel));
}
}
public IHttpActionResult Create(int?Id, TransactionBindingModel transactionBinding)
{
// Id being the id of the bankAccount
if (ModelState is null || !ModelState.IsValid || Id is null)
{
return(BadRequest(ModelState));
}
var bankAccount = DbContext.BankAccounts.FirstOrDefault(p => p.Id == Id);
if (bankAccount is null)
{
return(BadRequest("No bank account with that Id"));
}
// Ensure that the bank account and category are in the same houeshold.
if (!bankAccount.Household.Categories.Any(p => p.Id == transactionBinding.CategoryId))
{
return(BadRequest("No category with that Id"));
}
var transaction = new Transaction
{
Title = transactionBinding.Title,
Description = transactionBinding.Description,
CategoryId = transactionBinding.CategoryId,
Date = transactionBinding.Date,
Amount = transactionBinding.Amount,
CreatorId = User.Identity.GetUserId(),
DateCreated = DateTime.Now,
DateUpdated = null,
BankAccountId = (int)Id,
IsVoid = false
};
bankAccount.AddTransaction(transaction);
DbContext.SaveChanges();
var transactionView = TransactionHelpers.MapToView(transaction);
return(Created(Url.Link(
"GetTransactionById",
new { transaction.Id }),
transactionView
));
}
public IActionResult PostTransfer([FromBody] TransactionForDisplay transaction)
{
var transactions = new List <TransactionForDisplay>();
if (transaction.TransactionId == null || transaction.TransactionId == Guid.Empty)
{
transaction.TransactionId = Guid.NewGuid();
}
if (!transaction.AccountId.HasValue)
{
transaction.AccountId = _accountRepo.GetAll().Single(
a => a.Name.Equals(transaction.AccountName, StringComparison.CurrentCultureIgnoreCase)).AccountId;
}
transaction.SetAmount();
var relatedTransactionId = Guid.NewGuid();
var relatedTransaction = new TransactionForDisplay {
TransactionDate = transaction.TransactionDate,
TransactionId = relatedTransactionId,
Vendor = transaction.Vendor,
Description = transaction.Description,
AccountId = transaction.RelatedAccountId.Value,
Amount = 0 - transaction.Amount,
EnteredDate = DateTime.Now,
RelatedTransactionId = transaction.TransactionId
};
relatedTransaction.SetDebitAndCredit();
transaction.RelatedTransactionId = relatedTransactionId;
var bankFeeTransactions = TransactionHelpers.GetBankFeeTransactions(transaction, _categoryRepo, _accountRepo);
transactions.Add(transaction);
transactions.Add(relatedTransaction);
transactions.AddRange(bankFeeTransactions);
_transactionRepo.InsertRelatedTransaction(transaction, relatedTransaction);
foreach (var trx in bankFeeTransactions)
{
_transactionRepo.Insert(trx);
}
var accountBalances = _accountRepo.GetAccountBalances().Select(a => new { a.AccountId, a.CurrentBalance });
return(CreatedAtAction("PostTransfer",
new { id = transaction.TransactionId }, new { transactions, accountBalances }));
}
public ActionResult HouseholdTransactions(int?Id)
{
if (Id is null)
{
TempData.Add("Message", "Improper Id");
TempData.Add("MessageColour", "danger");
return(RedirectToAction("Index", "Household"));
}
var url = $"{ProjectConstants.APIURL}/api/transaction/getallbyhousehold/{Id}";
var token = Request.Cookies["UserAuthCookie"].Value;
var authHeader = new AuthenticationHeaderValue("Bearer", token);
HttpClientContext.httpClient.DefaultRequestHeaders.Authorization = authHeader;
// Handling lack of connection??? try catch?
var response = HttpClientContext.httpClient.GetAsync(url).Result;
if (response.IsSuccessStatusCode)
{
var responseResult = response.Content.ReadAsStringAsync().Result;
var datas = JsonConvert.DeserializeObject <List <TransactionViewModel> >(responseResult);
foreach (var item in datas)
{
item.CategoryName = HouseholdHelpers.GetCategoryName(item.CategoryId, Request);
item.BankAccountName = HouseholdHelpers.GetBankAccountName(item.BankAccountId, Request);
item.UserCanEdit = TransactionHelpers.IsUserCreator(item.Id, Request, TempData);
}
var viewModel = new TransactionListViewModel
{
Transactions = datas,
HouseholdId = (int)Id,
IsHouseholdOwnerOrMember = HouseholdHelpers.IsUserCreatorOrMember((int)Id, Request, TempData)
};
return(View(viewModel));
}
else
{
ErrorHelpers.HandleResponseErrors(response, TempData, ModelState);
return(RedirectToAction("Index", "Household"));
}
}
public TransactionPreviewViewModel(Wallet wallet, TransactionInfo info, BuildTransactionResult transaction)
{
_wallet = wallet;
_labels = SmartLabel.Empty;
_info = info;
SetupCancel(enableCancel: false, enableCancelOnEscape: true, enableCancelOnPressed: false);
EnableBack = true;
_confirmationTimeText = "";
var destinationAmount = transaction.CalculateDestinationAmount().ToDecimal(MoneyUnit.BTC);
var btcAmountText = $"{destinationAmount} bitcoins ";
var fiatAmountText = destinationAmount.GenerateFiatText(_wallet.Synchronizer.UsdExchangeRate, "USD");
AmountText = $"{btcAmountText}{fiatAmountText}";
AddressText = info.Address.ToString();
var fee = transaction.Fee;
var btcFeeText = $"{fee.ToDecimal(MoneyUnit.Satoshi)} sats ";
var fiatFeeText = fee.ToDecimal(MoneyUnit.BTC).GenerateFiatText(_wallet.Synchronizer.UsdExchangeRate, "USD");
FeeText = $"{btcFeeText}{fiatFeeText}";
PayJoinUrl = info.PayJoinClient?.PaymentUrl.AbsoluteUri;
IsPayJoin = PayJoinUrl is not null;
if (PreferPsbtWorkflow)
{
SkipCommand = ReactiveCommand.CreateFromTask(async() => await OnConfirmAsync(transaction));
NextCommand = ReactiveCommand.CreateFromTask(async() =>
{
var saved = await TransactionHelpers.ExportTransactionToBinaryAsync(transaction);
if (saved)
{
Navigate().To(new SuccessViewModel("The PSBT has been successfully created."));
}
});
_nextButtonText = "Save PSBT file";
}
else
{
NextCommand = ReactiveCommand.CreateFromTask(async() => await OnConfirmAsync(transaction));
_nextButtonText = "Confirm";
}
}
public static async IAsyncEnumerable <ChangeAvoidanceSuggestionViewModel> GenerateSuggestionsAsync(
TransactionInfo transactionInfo,
BitcoinAddress destination,
Wallet wallet,
ImmutableArray <SmartCoin> coinsToUse,
int maxInputCount,
decimal usdExchangeRate,
[EnumeratorCancellation] CancellationToken cancellationToken)
{
var selections = ChangelessTransactionCoinSelector.GetAllStrategyResultsAsync(
coinsToUse,
transactionInfo.FeeRate,
new TxOut(transactionInfo.Amount, destination),
maxInputCount,
cancellationToken).ConfigureAwait(false);
HashSet <Money> foundSolutionsByAmount = new();
await foreach (var selection in selections)
{
if (selection.Any())
{
BuildTransactionResult transaction = TransactionHelpers.BuildChangelessTransaction(
wallet,
destination,
transactionInfo.UserLabels,
transactionInfo.FeeRate,
selection,
tryToSign: false);
var destinationAmount = transaction.CalculateDestinationAmount();
// If BnB solutions become the same transaction somehow, do not show the same suggestion twice.
if (!foundSolutionsByAmount.Contains(destinationAmount))
{
foundSolutionsByAmount.Add(destinationAmount);
yield return(new ChangeAvoidanceSuggestionViewModel(
transactionInfo.Amount.ToDecimal(MoneyUnit.BTC),
transaction,
usdExchangeRate));
}
}
}
}
private async Task OnNext(TransactionBroadcaster broadcaster)
{
var transactionInfo = _transactionInfo;
var wallet = _owner.Wallet;
var targetAnonymitySet = wallet.ServiceConfiguration.GetMixUntilAnonymitySetValue();
var mixedCoins = wallet.Coins.Where(x => x.HdPubKey.AnonymitySet >= targetAnonymitySet).ToList();
var totalMixedCoinsAmount = Money.FromUnit(mixedCoins.Sum(coin => coin.Amount), MoneyUnit.Satoshi);
if (transactionInfo.Amount <= totalMixedCoinsAmount)
{
try
{
try
{
var txRes = await Task.Run(() => TransactionHelpers.BuildTransaction(wallet, transactionInfo.Address, transactionInfo.Amount, transactionInfo.Labels, transactionInfo.FeeRate, mixedCoins, subtractFee: false));
Navigate().To(new OptimisePrivacyViewModel(wallet, transactionInfo, broadcaster, txRes));
return;
}
catch (InsufficientBalanceException)
{
var txRes = await Task.Run(() => TransactionHelpers.BuildTransaction(wallet, transactionInfo.Address, totalMixedCoinsAmount, transactionInfo.Labels, transactionInfo.FeeRate, mixedCoins, subtractFee: true));
var dialog = new InsufficientBalanceDialogViewModel(BalanceType.Private, txRes, wallet.Synchronizer.UsdExchangeRate);
var result = await NavigateDialog(dialog, NavigationTarget.DialogScreen);
if (result.Result)
{
Navigate().To(new OptimisePrivacyViewModel(wallet, transactionInfo, broadcaster, txRes));
return;
}
}
}
catch (Exception ex)
{
Logger.LogError(ex);
await ShowErrorAsync("Transaction Building", ex.ToUserFriendlyString(), "Wasabi was unable to create your transaction.");
return;
}
}
Navigate().To(new PrivacyControlViewModel(wallet, transactionInfo, broadcaster));
}
public IActionResult MakeCorrectingEntries()
{
var investments = GetInvestments();
var currencyController = new CurrenciesController(_currencyRepo);
var currency = currencyController.GetExchangeRateFor("CAD").GetAwaiter().GetResult();
var investmentsTotal = investments.Sum(i => i.Price * i.Shares);
var totalInUsd = investmentsTotal / currency;
var investmentAccount = _accountRepo.GetAll().FirstOrDefault(a => a.AccountType == "Investment");
if (investmentAccount == null)
{
return(Ok());
}
var bookBalance = _transactionRepo.GetByAccount(investmentAccount.AccountId).Sum(i => i.Amount);
var difference = Math.Round(totalInUsd - bookBalance, 2);
if (Math.Abs(difference) >= 1)
{
var category = TransactionHelpers.GetOrCreateCategory("Gain/loss on investments", _categoryRepo);
var transaction = new TransactionForDisplay {
TransactionId = Guid.NewGuid(),
AccountId = investmentAccount.AccountId,
Amount = difference,
CategoryId = category.CategoryId,
CategoryName = category.Name,
CategoryDisplay = category.Name,
TransactionDate = DateTime.Now,
EnteredDate = DateTime.Now,
Description = "Gain/loss"
};
transaction.SetDebitAndCredit();
_transactionRepo.Insert(transaction);
var accountBalances = _accountRepo.GetAccountBalances().Select(a => new { a.AccountId, a.CurrentBalance });
var transactions = new[] { transaction };
return(CreatedAtAction("PostTransaction", new { id = transaction.TransactionId }, new { transactions, accountBalances }));
}
else
{
return(Ok());
}
}
