private void CreatePoll(VotingModel votingModel, MinBalanceModel balanceModel, ulong?holdingId)
{
var name = Utilities.GenerateRandomString(10);
var description = Utilities.GenerateRandomString(30);
var finishHeight = TestSettings.MaxHeight + 1000;
const int minNumberOfOptions = 1;
const int maxNumberOfOptions = 1;
const int minRangeValue = 0;
const int maxRangeValue = 1;
var options = new List <string> {
"How are you doing?"
};
const int minBalance = 1;
var createPollParameters = new CreatePollParameters(name, description, finishHeight, votingModel,
minNumberOfOptions, maxNumberOfOptions, minRangeValue, maxRangeValue, options)
{
MinBalance = minBalance,
MinBalanceModel = balanceModel,
HoldingId = holdingId
};
var createPollReply = _votingSystemService.CreatePoll(createPollParameters,
CreateTransaction.CreateTransactionBySecretPhrase(fee: Amount.CreateAmountFromNxt(10))).Result;
VerifyCreatePollParameters(createPollParameters, createPollReply.Transaction.Attachment as MessagingPollCreationAttachment);
}
internal Transaction CreateToTransaction(CreateTransaction create)
{
var amount = CreateToTransactionAmount(create.Amount);
var ts = DateTime.UtcNow;
return(new Transaction(create.AccountId, create.Id, create.Label, amount, create.Metadata, create.Description, ts, ts));
}
private void TestSetPhasingOnlyControl()
{
using (Logger = new TestsessionLogger(_logger))
{
var votingModel = VotingModel.Account;
var controlQuorum = 1;
var byPublicKey = CreateTransaction.CreateTransactionByPublicKey();
var controlMinBalance = 1000;
var controlMinBalanceModel = VotingModel.Nqt;
var controlMaxFees = Amount.CreateAmountFromNxt(1000);
var phasingOnlyControl = _service.SetPhasingOnlyControl(votingModel, controlQuorum,
byPublicKey, controlMinBalance, controlMinBalanceModel, null,
new[] { TestSettings.Account2.AccountRs }, controlMaxFees).Result;
var attachment = (AccountControlSetPhasingOnlyAttachment)phasingOnlyControl.Transaction.Attachment;
AssertEquals((int)votingModel, (int)attachment.PhasingVotingModel, nameof(attachment.PhasingVotingModel));
AssertEquals(controlQuorum, attachment.PhasingQuorum, nameof(attachment.PhasingQuorum));
AssertEquals(controlMinBalance, attachment.PhasingMinBalance, nameof(attachment.PhasingMinBalance));
AssertEquals((int)controlMinBalanceModel, (int)attachment.PhasingMinBalanceModel, nameof(attachment.PhasingMinBalanceModel));
AssertEquals(controlMaxFees.Nqt, attachment.ControlMaxFees.Nqt, nameof(attachment.ControlMaxFees));
AssertEquals(1, attachment.PhasingWhitelist.Count(), "attachment.PhasingWhitelist.Count()");
AssertEquals(attachment.PhasingWhitelist.Single(), TestSettings.Account2.AccountId, nameof(attachment.PhasingWhitelist));
}
}
public async Task Consume(ConsumeContext <AccountCreated> context)
{
//var ser = JsonSerializer.Serialize(context.Message);
var acc = context.Message.Event.To();
Console.WriteLine($"Receive created account with {acc.Id.Value.Value} with convId = {context.ConversationId} ");
var createTran = new CreateTransaction(
acc.Id,
new TransactionId(UniqId.New()),
new TransactionLabel("user2user_source"),
new CreateAmountCompletedIncome(AmountFactory.New("10.00", CurrencyFactory.New("MXN"))),
"asdasd"
);
await context.Publish(CreateTransactionCommand.From(createTran));
createTran = new CreateTransaction(
acc.Id,
new TransactionId(UniqId.New()),
new TransactionLabel("user2user_destination"),
new CreateAmountCompletedIncome(AmountFactory.New("10.00", CurrencyFactory.New("MXN"))),
"asdasd"
);
await context.Publish(CreateTransactionCommand.From(createTran));
}
//public async Task<IActionResult> Create([Bind("Id,Date,Title,Sum")] Transaction transaction)
public async Task <IActionResult> Create(CreateTransaction newTransaction)
{
try
{
string currentUserId = _userManager.GetUserId(HttpContext.User);
if (ModelState.IsValid)
{
var recipientBankAccount = _context.BankAccounts.Where(x => x.Number == newTransaction.RecipientBankAccount).FirstOrDefault();
var recipientUniqueName = _context.Users.Where(x => x.NormalizedUserName == newTransaction.RecipientUniqueName.ToUpper().Trim()).FirstOrDefault();
var senderAccountAmount = _context.BankAccounts.Where(s => s.Id == newTransaction.SenderBankAccountId).FirstOrDefault();
//If Adding Errore
if (senderAccountAmount.Balance < newTransaction.Sum)
{
var senderBankAccountsList = _context.BankAccounts.Where(a => a.User.Id == currentUserId).Select(b => new { Id = b.Id, Value = b.Number });
newTransaction.SenderBankAccountsList = new SelectList(senderBankAccountsList, "Id", "Value");
ModelState.AddModelError("Sum", "Not enough amount of money on your account");
return(View(newTransaction));
}
if (recipientUniqueName == null)
{
var senderBankAccountsList = _context.BankAccounts.Where(a => a.User.Id == currentUserId).Select(b => new { Id = b.Id, Value = b.Number });
newTransaction.SenderBankAccountsList = new SelectList(senderBankAccountsList, "Id", "Value");
ModelState.AddModelError("RecipientUniqueName", "Recipient name does not exist.");
return(View(newTransaction));
}
if (recipientBankAccount == null)
{
var senderBankAccountsList = _context.BankAccounts.Where(a => a.User.Id == currentUserId).Select(b => new { Id = b.Id, Value = b.Number });
newTransaction.SenderBankAccountsList = new SelectList(senderBankAccountsList, "Id", "Value");
ModelState.AddModelError("RecipientBankAccount", "Recipient account number does not exist.");
return(View(newTransaction));
}
Transaction transaction = new Transaction()
{
Date = newTransaction.Date,
Sender = _context.Users.Where(s => s.Id == currentUserId).FirstOrDefault(),
Reciver = _context.Users.Where(r => r.NormalizedUserName == newTransaction.RecipientUniqueName).FirstOrDefault(),
Title = newTransaction.Title,
Sum = newTransaction.Sum,
SenderAccount = _context.BankAccounts.Where(s => s.Id == newTransaction.SenderBankAccountId).FirstOrDefault(),
ReciverAccount = _context.BankAccounts.Where(s => s.Number == newTransaction.RecipientBankAccount).FirstOrDefault()
};
senderAccountAmount.Balance = senderAccountAmount.Balance - newTransaction.Sum;
recipientBankAccount.Balance = recipientBankAccount.Balance + newTransaction.Sum;
_context.Add(transaction);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(newTransaction));
}
catch (Exception)
{
throw;
}
}
public async Task can_send()
{
SetupServerSingleResponse(Transaction6);
var createTx = new CreateTransaction
{
Type = "send",
To = "1AUJ8z5RuHRTqD1eikyfUUetzGmdWLGkpT",
Amount = 0.1m,
Currency = "BTC",
Idem = "9316dd16-0c05"
};
var r = await client.Transactions.SendMoneyAsync("fff", createTx);
var truth = new Response <Transaction>
{
Data = Transaction6Model
};
truth.Should().BeEquivalentTo(r);
server.ShouldHaveRequestBody(
"{\"type\":\"send\",\"to\":\"1AUJ8z5RuHRTqD1eikyfUUetzGmdWLGkpT\",\"amount\":0.1,\"currency\":\"BTC\",\"skip_notifications\":false,\"idem\":\"9316dd16-0c05\",\"to_financial_institution\":false}");
server.ShouldHaveExactCall($"https://api.coinbase.com/v2/accounts/fff/transactions")
.WithVerb(HttpMethod.Post);
}
public async Task Examples_RunSuccessfully()
{
// Arrange
GlobalConfiguration.Instance = GlobalConfiguration.MergeConfigurations(GlobalConfiguration.Instance, new Configuration
{
DateTimeFormat = "yyyy-MM-dd"
});
var budgetMonthId = "2019-08-01";
var budgetId = new Guid("14235236-8085-4cf6-9fa6-92c34ed44b0c");
var categoryId = new Guid("3b89df53-1869-4d2f-a636-d09eadc3f0ca");
// Act
// Assert
try {
using (var stub = new YnabApiStub()) {
var api = new API(_token, stub.BasePath);
var ble = new BudgetListExample(api);
ble.Execute();
await ble.ExecuteAsync();
var bme = new BudgetMonthExample(api);
bme.Execute(budgetId, budgetMonthId);
await bme.ExecuteAsync(budgetId, budgetMonthId);
var btc = new BulkTransactionCreate(api);
// btc.Execute();
// await btc.ExecuteAsync();
var cbe = new CategoryBalanceExample(api);
cbe.Execute(budgetId, categoryId);
await cbe.ExecuteAsync(budgetId, categoryId);
var cmt = new CreateMultipleTransactions(api);
// cmt.Execute();
// await cmt.ExecuteAsync();
var ct = new CreateTransaction(api);
ct.Execute();
await ct.ExecuteAsync();
var dre = new DeltaRequestExample(api);
dre.Execute();
await dre.ExecuteAsync();
var ucb = new UpdateCategoryBudgeted(api);
// ucb.Execute();
// await ucb.ExecuteAsync();
var ut = new UpdateTransaction(api);
// ut.Execute();
// await ut.ExecuteAsync();
}
} catch (Exception ex) {
Assert.True(false, ex.Message);
}
Assert.True(true, "Finished running examples");
}
private void TestDeleteAccountProperty()
{
using (Logger = new TestsessionLogger(_logger))
{
var reply = _service.DeleteAccountProperty(CreateTransaction.CreateTransactionByPublicKey(), "testkey1").Result;
var attachment = (MessagingAccountPropertyDeleteAttachment)reply.Transaction.Attachment;
AssertEquals(940296349549404868, attachment.Property, nameof(attachment.Property));
}
}
public HttpResponseMessage Post(CreateTransaction model)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest,
ModelState));
}
var account = DataContext.Accounts.Find(model.AccountId);
if ((account == null) || (account.UserId != UserId))
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
var category = DataContext.Categories.Find(model.CategoryId);
if ((category == null) || (category.UserId != UserId))
{
ModelState.AddModelError(
"CategoryId",
"Specified category does not exist.");
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest, ModelState));
}
Transaction transaction;
switch (category.Type)
{
case CategoryType.Expense:
transaction = account.Withdraw(model.Amount);
break;
case CategoryType.Income:
transaction = account.Deposit(model.Amount);
break;
default:
throw new InvalidOperationException(
"Invalid category type.");
}
transaction.Merge(model, new[] { "Payee", "Notes", "PostedAt" });
transaction.Category = category;
DataContext.Transactions.Add(transaction);
DataContext.SaveChanges();
return(Request.CreateResponse(
HttpStatusCode.Created,
transaction.AsModel()));
}
public static async Task <Manifest> GetDefaultObject(BaseAddress addressTo)
{
var parameters0 = new CreateShipment();
Address addressFrom = await AddressTest.GetDefaultObject();
Parcel parcel = await ParcelTest.GetDefaultObject();
parameters0.AddressFrom = addressFrom.ObjectId;
parameters0.AddressTo = addressTo;
parameters0.AddParcel(parcel.ObjectId);
parameters0.ShipmentDate = DateTime.Now;
parameters0.CustomsDeclaration = "";
parameters0.Extra = new ShipmentExtra
{
Insurance = new ShipmentExtraInsurance
{
Amount = 30,
Currency = "USD"
},
SignatureConfirmation = ShippoEnums.SignatureConfirmations.STANDARD
};
parameters0.Metadata = "Customer ID 123456";
parameters0.Async = false;
Shipment shipment = await GetShippoClient().CreateShipment(parameters0);
ShippoCollection <Rate> rateCollection = await GetShippoClient().GetShippingRatesSync(shipment.ObjectId, "USD");
List <Rate> rateList = rateCollection.Data;
Rate[] rateArray = rateList.ToArray();
var createTransaction = new CreateTransaction
{
Rate = rateArray[0].ObjectId,
Metadata = "Customer ID 123456"
};
Transaction transaction = await GetShippoClient().CreateTransactionSync(createTransaction);
var parameters2 = new CreateManifest
{
ShipmentDate = DateTime.Now,
AddressFromObjectId = addressFrom.ObjectId,
Provider = "usps"
};
var transactions = new List <string>();
transactions.Add(transaction.ObjectId);
parameters2.TransactionsIds = transactions.ToArray();
return(await GetShippoClient().CreateManifest(parameters2));
}
public dynamic CreateTransaction(CreateTransaction vm)
{
var index = blockchain.NewTransaction(
vm.Sender,
vm.Recipient,
vm.Amount);
return(Ok(new
{
message = $"Transaction will be added to block {index}"
}));
}
public bool MakeTransfer(IBankAppDataContext context)
{
CreateTransaction createTransaction = new CreateTransaction(context);
if (createTransaction.Transfer(FromAccount, ToAccount, Amount))
{
StatusMessage = "Transfer successful";
return(true);
}
StatusMessage = createTransaction.ErrorMessage;
return(false);
}
public bool MakeDeposit(IBankAppDataContext context)
{
CreateTransaction createTransaction = new CreateTransaction(context);
if (createTransaction.Deposit(Account, Amount))
{
StatusMessage = "Deposit successful";
return(true);
}
StatusMessage = createTransaction.ErrorMessage;
return(false);
}
public bool MakeWithdrawal()
{
Withdrawal = true;
CreateTransaction createTransaction = new CreateTransaction(_context);
if (createTransaction.Withdrawal(FromAccount, Amount))
{
StatusMessage = "Withdrawal successful";
return(true);
}
return(false);
}
public bool MakeTransfer()
{
Transfer = true;
CreateTransaction createTransaction = new CreateTransaction(_context);
if (createTransaction.Transfer(FromAccount, ToAccount, Amount))
{
StatusMessage = "Transfer successful";
return(true);
}
return(false);
}
public bool MakeDeposit()
{
Deposit = true;
CreateTransaction createTransaction = new CreateTransaction(_context);
if (createTransaction.Deposit(ToAccount, Amount))
{
StatusMessage = "Deposit successful";
return(true);
}
return(false);
}
private void TestCalculateFullHash()
{
using (Logger = new TestsessionLogger(_logger))
{
var unsignedSendMoney = _accountService.SendMoney(CreateTransaction.CreateTransactionByPublicKey(), TestSettings.Account2.AccountRs, Amount.OneNqt).Result;
var signedTransaction = _transactionService.SignTransaction(new TransactionParameter(unsignedSendMoney.UnsignedTransactionBytes), TestSettings.SecretPhrase1).Result;
var signatureHash = signedTransaction.Transaction.SignatureHash;
var calculateFullHash = _transactionService.CalculateFullHash(new BinaryHexString(signatureHash), unsignedSendMoney.UnsignedTransactionBytes).Result;
AssertEquals(signedTransaction.FullHash.ToHexString(), calculateFullHash.FullHash.ToHexString(), "FullHash");
}
}
public HttpResponseMessage Post(CreateTransaction model)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(
HttpStatusCode.BadRequest,
ModelState);
}
var account = DataContext.Accounts.Find(model.AccountId);
if ((account == null) || (account.UserId != UserId))
{
return Request.CreateResponse(HttpStatusCode.NotFound);
}
var category = DataContext.Categories.Find(model.CategoryId);
if ((category == null) || (category.UserId != UserId))
{
ModelState.AddModelError(
"CategoryId",
"Specified category does not exist.");
return Request.CreateErrorResponse(
HttpStatusCode.BadRequest, ModelState);
}
Transaction transaction;
switch (category.Type)
{
case CategoryType.Expense:
transaction = account.Withdraw(model.Amount);
break;
case CategoryType.Income:
transaction = account.Deposit(model.Amount);
break;
default:
throw new InvalidOperationException(
"Invalid category type.");
}
transaction.Merge(model, new[] { "Payee", "Notes", "PostedAt" });
transaction.Category = category;
DataContext.Transactions.Add(transaction);
DataContext.SaveChanges();
return Request.CreateResponse(
HttpStatusCode.Created,
transaction.AsModel());
}
public async Task <CreateSlothTransactionResponse> CreateTransaction(CreateTransaction transaction)
{
using (var client = GetHttpClient())
{
var url = "transactions";
var response = await client.PostAsJsonAsync(url, transaction);
var result = await response.GetContentOrNullAsync <CreateSlothTransactionResponse>();
return(result);
}
}
internal void TestUploadTaggedData()
{
using (Logger = new TestsessionLogger(_logger))
{
var parameters = CreateTransaction.CreateTransactionByPublicKey();
var transaction = _taggedDataService.UploadTaggedData(Name, Data, parameters, null, Description, Tags, Channel, Type, IsText,
Filename).Result.Transaction;
var attachment = (TaggedDataUploadAttachment)transaction.Attachment;
VerifyMembers(attachment);
}
}
private void TestDeleteAssetShares()
{
using (Logger = new TestsessionLogger(_logger))
{
var quantityQnt = 1;
var deleteAssetSharesReply = _service.DeleteAssetShares(TestSettings.ExistingAssetId, quantityQnt,
CreateTransaction.CreateTransactionByPublicKey()).Result;
var attachment = (ColoredCoinsDeleteAttachment)deleteAssetSharesReply.Transaction.Attachment;
AssertEquals(TestSettings.ExistingAssetId, attachment.AssetId, nameof(attachment.AssetId));
AssertEquals(quantityQnt, attachment.QuantityQnt, nameof(attachment.QuantityQnt));
}
}
private void TestExtendTaggedData()
{
using (Logger = new TestsessionLogger(_logger))
{
var parameters = CreateTransaction.CreateTransactionByPublicKey();
var transaction = _taggedDataService.ExtendTaggedData(TestSettings.TaggedDataTransactionId, parameters, Name, Data, null,
Description, Tags, Channel, Type, IsText, Filename).Result.Transaction;
var attachment = (TaggedDataExtendAttachment)transaction.Attachment;
VerifyMembers(attachment);
AssertEquals(TestSettings.TaggedDataTransactionId, attachment.TaggedDataId, "TaggedDataId");
}
}
private void SendUnencryptedData()
{
using (Logger = new TestsessionLogger(_logger))
{
byte[] expected = { 4, 7, 1, 64, 23, 91, 1, 45, 23 };
var parameters = CreateTransaction.CreateTransactionByPublicKey(Amount.CreateAmountFromNxt(3));
parameters.Message = new CreateTransactionParameters.UnencryptedMessage(expected);
var sendMessageResult = _messageService.SendMessage(parameters).Result;
var actual = sendMessageResult.Transaction.Message;
AssertEquals(expected, actual.Data.ToBytes().ToArray(), nameof(actual.Data));
AssertIsFalse(actual.IsText, nameof(actual.IsText));
AssertIsFalse(actual.IsPrunable, nameof(actual.IsPrunable));
}
}
private void SendPrunableMessage()
{
using (Logger = new TestsessionLogger(_logger))
{
const string expected = "Hello World!";
var parameters = CreateTransaction.CreateTransactionByPublicKey(Amount.CreateAmountFromNxt(3));
parameters.Message = new CreateTransactionParameters.UnencryptedMessage(expected, true);
var sendMessageResult = _messageService.SendMessage(parameters).Result;
var actual = sendMessageResult.Transaction.Message;
AssertEquals(expected, actual.MessageText, nameof(actual.MessageText));
AssertIsTrue(actual.IsText, nameof(actual.IsText));
AssertIsTrue(actual.IsPrunable, nameof(actual.IsPrunable));
}
}
private void TestSignTransaction()
{
using (Logger = new TestsessionLogger(_logger))
{
var amount = Amount.OneNqt;
var recipient = TestSettings.Account2.AccountRs;
var unsignedSendMoney = _accountService.SendMoney(CreateTransaction.CreateTransactionByPublicKey(), recipient, amount).Result;
var signedTransaction = _transactionService.SignTransaction(new TransactionParameter(unsignedSendMoney.UnsignedTransactionBytes), TestSettings.SecretPhrase1).Result;
var transaction = signedTransaction.Transaction;
AssertEquals(transaction.Amount.Nqt, Amount.OneNqt.Nqt, "Amount");
AssertEquals(transaction.RecipientRs, recipient, "RecipientRs");
}
}
// GET: Transactions/Create
public IActionResult Create()
{
string currentUserId = _userManager.GetUserId(HttpContext.User);
var senderBankAccountsList = _context.BankAccounts.Where(a => a.User.Id == currentUserId).Select(b => new { Id = b.Id, Value = b.Number });
CreateTransaction viewModel = new CreateTransaction
{
SenderBankAccountsList = new SelectList(senderBankAccountsList, "Id", "Value"),
Title = "Default Transaction",
Date = DateTime.Now,
Sum = 1
};
return(View(viewModel));
}
private void TestSetAccountProperty()
{
using (Logger = new TestsessionLogger(_logger))
{
var property = "key1";
var value = "supersecret";
var accountProperty = _service.SetAccountProperty(CreateTransaction.CreateTransactionByPublicKey(), property, value).Result;
var attachment = (MessagingAccountPropertyAttachment)accountProperty.Transaction.Attachment;
// ReSharper disable once PossibleInvalidOperationException
AssertEquals(accountProperty.Transaction.Recipient.Value, TestSettings.Account1.AccountId, "recipient");
AssertEquals(property, attachment.Property, nameof(attachment.Property));
AssertEquals(value, attachment.Value, nameof(attachment.Value));
}
}
public static async Task <Transaction> GetDefaultObject()
{
ShippoCollection <Rate> rateCollection = await RateTest.GetDefaultObject();
List <Rate> rateList = rateCollection.Data;
Rate[] rateArray = rateList.ToArray();
var parameters = new CreateTransaction
{
Rate = rateArray[0].ObjectId,
Metadata = "Customer ID 123456"
};
return(await GetShippoClient().CreateTransactionSync(parameters));
}
public ActionResult CreateTransaction([FromBody] CreateTransaction model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var transaction = db.CreateTransaction(model.UserFromId, model.UserToId, model.Amount);
return(Ok(transaction.Id));
}
catch (Exception err)
{
return(BadRequest(err.Message));
}
}
private void SendEncryptedMessageToSelfBySecretPhrase()
{
using (Logger = new TestsessionLogger(_logger))
{
const string expected = "Hello World!";
var parameters = CreateTransaction.CreateTransactionBySecretPhrase(false, Amount.CreateAmountFromNxt(3));
parameters.EncryptedMessageToSelf = new CreateTransactionParameters.MessageToBeEncryptedToSelf(expected, true);
var sendMesageResult = _messageService.SendMessage(parameters).Result;
var actual = sendMesageResult.Transaction.EncryptToSelfMessage;
AssertIsTrue(actual.IsCompressed, nameof(actual.IsCompressed));
AssertIsTrue(actual.IsText, nameof(actual.IsText));
AssertIsNull(actual.MessageToEncrypt, nameof(actual.MessageToEncrypt));
AssertIsNotNull(actual.Data, nameof(actual.Data));
AssertIsNotNull(actual.Nonce, nameof(actual.Nonce));
}
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
var client = new CoinbaseClient();
var create = new CreateTransaction
{
Amount = 1.0m,
Currency = "BTC"
};
var response = await client
.WithHeader(TwoFactorToken, "ffff")
.Transactions.SendMoneyAsync("accountId", create);
if (!response.HasError())
{
// transaction is okay!
}
}
