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! } }