Ejemplo n.º 1
0
        protected void ucIEdit_InstanceSaving(object sender, InstanceSavingEventArgs e)
        {
            TransactionDto instance = e.Instance as TransactionDto;

            if (instance != null)
            {
                using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CRMDataStoreKey))
                {
                    TransactionFacade facade = new TransactionFacade(uow);
                    IFacadeUpdateResult <TransactionData> result = facade.SaveTransaction(instance);
                    e.IsSuccessful = result.IsSuccessful;
                    if (result.IsSuccessful)
                    {
                        // Refresh Instance
                        CurrentInstance = result.ToDto <TransactionDto>(new TransactionConverter());
                    }
                    else
                    {
                        // Deal with Update result
                        ProcUpdateResult(result.ValidationResult, result.Exception);
                    }
                }
            }
        }
Ejemplo n.º 2
0
        public IActionResult ExtendSubscriptionStripe([FromBody] StripePaymentRequest paymentRequest)
        {
            //Stripe developer api key
            StripeConfiguration.SetApiKey("sk_test_IhD98M0gMGB1G7rbcHifS3GP");

            //configuration of stripe chrarge object
            var myCharge = new StripeChargeCreateOptions();

            myCharge.SourceTokenOrExistingSourceId = paymentRequest.tokenId;
            myCharge.Amount             = paymentRequest.amount;
            myCharge.Currency           = "gbp";
            myCharge.Description        = paymentRequest.productName;
            myCharge.Metadata           = new Dictionary <string, string>();
            myCharge.Metadata["OurRef"] = "OurRef-" + Guid.NewGuid().ToString();

            var          chargeService = new StripeChargeService();
            StripeCharge stripeCharge  = chargeService.Create(myCharge);

            if (stripeCharge.Status.Equals("succeeded"))
            {
                TransactionDto transaction = new TransactionDto();
                transaction.Amount           = (decimal)(paymentRequest.amount / 100.0);
                transaction.Status           = "succeeded";
                transaction.CustomerId       = 1;
                transaction.PaymentGatewayId = 1;
                transaction.PricingPackageId = paymentRequest.packageId;
                transaction.DateCreated      = DateTime.Now;
                _transactionManipulation.SaveTransaction(transaction);


                SubscriptionDto subscription = _subscriptionManipulation.GetCustomerSubscription(1);
                subscription.SubscriptionExpirationDate = subscription.SubscriptionExpirationDate.AddMonths(1);
                _subscriptionManipulation.UpdateSubscription(subscription);
            }
            return(Ok(stripeCharge));
        }
Ejemplo n.º 3
0
        public TransactionDto Deposit(TransactionDto transactionDto)
        {
            var card        = _cardRepository.GetCardByNumberAndSecurityCode(transactionDto.Number, transactionDto.SecurityCode);
            var cardDto     = HydrateCardDto(card);
            var transaction = HydrateTransaction(transactionDto, cardDto);


            var balanceValidate = new BalanceValidation(card.Balance);


            if (!card.Active)
            {
                return(HydrateTransactionDto(transaction, ExceptionConstants.CARD_BLOCKED));
            }


            if ((card.Number.Equals(transactionDto.Number)))
            {
                _cardRepository.UpdateBalance(card, transaction.Amount);
                _repository.Add(transaction);
            }

            return(HydrateTransactionDto(transaction, ExceptionConstants.CREATE_SUCCESS));
        }
Ejemplo n.º 4
0
        public void FromDto_Transaction()
        {
            using (var testDbInfo = SetupUtil.CreateTestDb())
            {
                //Arrange
                Mock <ILog>   mockLog      = new Mock <ILog>();
                RepositoryBag repositories = SetupUtil.CreateMockRepositoryBag(testDbInfo.ConnectionString, mockLog.Object);


                DateTime timestamp       = DateTime.Now;
                long?    sourceAccountId = 1;
                long?    destAccountId   = 3;
                Money    transferAmount  = 123.45;
                string   memo            = "memo";

                TransactionDto transactionDto = new TransactionDto()
                {
                    Id                   = 1,
                    Timestamp            = timestamp,
                    SourceAccountId      = sourceAccountId,
                    DestinationAccountId = destAccountId,
                    TransferAmount       = transferAmount.InternalValue,
                    Memo                 = memo
                };

                //Act
                Transaction transaction = DtoToModelTranslator.FromDto(transactionDto, repositories);

                //Assert
                Assert.Equal(timestamp, transaction.Timestamp);
                Assert.Equal(sourceAccountId, transaction.SourceAccountId);
                Assert.Equal(destAccountId, transaction.DestinationAccountId);
                Assert.Equal(transferAmount, transaction.TransferAmount);
                Assert.Equal(memo, transaction.Memo);
            }
        }
Ejemplo n.º 5
0
        public IHttpActionResult PayTransaction(TransactionDto requestParam)
        {
            try
            {
                var json = JsonConvert.SerializeObject(requestParam);
                log(json);

                if (!ModelState.IsValid)
                {
                    var message = string.Join(" | ", ModelState.Values
                                              .SelectMany(v => v.Errors)
                                              .Select(e => e.ErrorMessage));

                    var error = new ErorrMessage()
                    {
                        ResponseCode   = 403,
                        ResponseStatus = false,
                        Message        = message
                    };

                    return(ResponseMessage(Request.CreateResponse(HttpStatusCode.Forbidden, error)));
                }

                var transactionResponse = util.PayTransaction(requestParam);
                if (!transactionResponse)
                {
                    return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NotFound, ErrorResponse(404, "Unable to capture record"))));
                }

                return(Ok(SuccessResponse(200, "successful", transactionResponse)));
            }
            catch (Exception ex)
            {
                return(ResponseMessage(Request.CreateResponse(HttpStatusCode.InternalServerError, ErrorResponse(500, ex.Message.ToString()))));
            }
        }
        public async Task AddMonthlyFixedTransaction(TransactionDto monthlyTransaction)
        {
            var user = await _userHelper.GetCurrentUser();

            var transactions = new List <Transaction>();

            var numberOfDaysInMonth = DateTime.DaysInMonth(monthlyTransaction.Date.Year, monthlyTransaction.Date.Month);

            for (var i = 1; i <= numberOfDaysInMonth; i++)
            {
                transactions.Add(new Transaction
                {
                    Amount      = monthlyTransaction.Amount / numberOfDaysInMonth,
                    Description = monthlyTransaction.Description,
                    Date        = new DateTime(monthlyTransaction.Date.Year, monthlyTransaction.Date.Month, i),
                    User        = user,
                    UserId      = user.Id
                });
            }

            _unitOfWork.TransactionsRepository.Add(transactions);

            await _unitOfWork.SaveAsync();
        }
        public TransactionDto Read(string id)
        {
            TransactionDto dtoToReturn = null;

            using (SqlConnection sqlConnection = new SqlConnection(connectionString))
            {
                sqlConnection.Open();
                using (SqlDataAdapter adapter = new SqlDataAdapter(sql, connectionString))
                {
                    DataSet dataSet = new DataSet();
                    adapter.Fill(dataSet, "Transactions");
                    dataSet.Tables["Transactions"].PrimaryKey = new DataColumn[] { dataSet.Tables["Transactions"].Columns["Id"] };

                    DataRow dataRowToReturn = dataSet.Tables["Transactions"].Rows.Find(id);

                    foreach (var item in dataRowToReturn.ItemArray.ToList())
                    {
                        Console.WriteLine(item);
                    }
                }
                sqlConnection.Close();
            }
            return(null);
        }
Ejemplo n.º 8
0
        public IActionResult CreatePaypalTransaction([FromBody] PaypalPaymentRequest paymentRequest)
        {
            Console.WriteLine(paymentRequest.paymentNonce);
            Braintree.TransactionRequest request = new Braintree.TransactionRequest()
            {
                PaymentMethodNonce = paymentRequest.paymentNonce,
                Amount             = (decimal)(paymentRequest.amount)
            };

            Braintree.Result <Braintree.Transaction> result = gateway.Transaction.Sale(request);
            if (result.IsSuccess())
            {
                TransactionDto transaction = new TransactionDto();
                transaction.Amount           = (decimal)(paymentRequest.amount);
                transaction.Status           = "succeeded";
                transaction.CustomerId       = 1;
                transaction.PaymentGatewayId = 2;
                transaction.PricingPackageId = paymentRequest.packageId;
                transaction.DateCreated      = DateTime.Now;
                _transactionManipulation.SaveTransaction(transaction);


                SubscriptionDto subscription = new SubscriptionDto();
                subscription.CustomerId       = 1;
                subscription.PricingPackageId = paymentRequest.packageId;

                _subscriptionManipulation.GetCustomerSubscription(1);

                _subscriptionManipulation.SaveSubscription(subscription);
                return(Ok("Uspjesan placanje"));
            }
            else
            {
                return(BadRequest("Neuspjesna transakcija!"));
            }
        }
Ejemplo n.º 9
0
        public async Task <PaymentResponse> Refund(TransactionDto transactionDto)
        {
            var customer = await repository.GetByIdWithIncludeAsync <Customer>(
                transactionDto.TransactionId, new[] { Constants.TransactionHistories });

            if (customer.Status == Status.Refunded || customer.Status == Status.Void)
            {
                throw new ValidationException("cannot refund anymore");
            }

            var authorizedAmount     = GetAmount(customer, TransactionType.Authorize);
            var captureAmount        = GetAmount(customer, TransactionType.Capture);
            var previousRefundAmount = GetAmount(customer, TransactionType.Refund);

            if (previousRefundAmount + transactionDto.Amount > captureAmount)
            {
                throw new ValidationException("Invalid refund request, Refund amount exceeds capture amount");
            }

            //full refund and no more refund
            if (previousRefundAmount + transactionDto.Amount == captureAmount)
            {
                customer.Status = Status.Refunded;
            }

            customer.BankAmount = (authorizedAmount - captureAmount) + previousRefundAmount + transactionDto.Amount;
            customer.TransactionHistories.Add(new TransactionHistory
            {
                Amount = transactionDto.Amount,
                Type   = TransactionType.Refund
            });

            await repository.UpdateAsync(customer);

            return(new PaymentResponse(customer.BankAmount, customer.Currency));
        }
Ejemplo n.º 10
0
        public void UpdateSyncTransaction(TransactionDto txn)
        {
            String tsql = @"[Sync].[SP_UpdateSyncTransaction]";

            try
            {
                var colParameters = new DBHelper.Parameters[]
                {
                    new DBHelper.Parameters("@IsSyncReady", txn.IsSyncReady),
                    new DBHelper.Parameters("@SyncDate", txn.SyncDate),
                    new DBHelper.Parameters("@SyncRefNo", txn.SyncRefNo),
                    new DBHelper.Parameters("@SyncRefCreatedOn", txn.SyncRefCreatedOn),
                    new DBHelper.Parameters("@SyncRefModifiedOn", txn.SyncRefModifiedOn),
                    new DBHelper.Parameters("@ReasonSyncFailed", txn.ReasonSyncFailed ?? string.Empty),
                    new DBHelper.Parameters("@SyncFailedCount", txn.SyncFailedCount),
                    new DBHelper.Parameters("@Id", txn.Id)
                };

                this.ExecuteNonQuery(CommandType.StoredProcedure, tsql, colParameters);
            }
            catch (DBConcurrencyException)
            {
            }
        }
Ejemplo n.º 11
0
        public static async Task PublishUserDepositCanceledIntegrationEventAsync(this IServiceBusPublisher publisher, UserId userId, TransactionDto transaction)
        {
            var integrationEvent = new UserDepositCanceledIntegrationEvent
            {
                UserId      = userId,
                Transaction = transaction
            };

            await publisher.PublishAsync(integrationEvent);
        }
Ejemplo n.º 12
0
        public void TestTransaction()
        {
            Rendu.Clear();

            addToOc(ActionsEnum.Travail.ToString(), ServiceEnum.Transaction.ToString());

            #region Nouvelle Categorie, Nouveau Account

            var newCategory = new CategoryDto();
            newCategory.Balance = 7.0;
            newCategory.Color = "AA";
            newCategory.Name = "MyCategory";

            var newAccount = new AccountDto();
            newAccount.Balance = 7.0;
            newAccount.BankName = "AA";
            newAccount.Name = "MyAccount";

            #endregion

            #region Nettoyage Base

            var Categories = CategoryService.GetAllCategories(false, false);

            addToOc(ActionsEnum.GetList.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Category.ToString(), ObjectType.itemCount.ToString(), Categories.Value.Count));


            var Accounts = AccountService.GetAllAccounts(false, false);

            addToOc(ActionsEnum.GetList.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Account.ToString(), ObjectType.itemCount.ToString(), Accounts.Value.Count));



            if (Categories.Value.Count > 0)
            {
                foreach (var dto in Categories.Value)
                {
                    CategoryService.DeleteCategorieById(dto.Id);
                    addToOc(ActionsEnum.Delete.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Category.ToString(), ObjectType.itemId.ToString(), dto.Id));
                }

                Categories = CategoryService.GetAllCategories(false, false);

                addToOc(ActionsEnum.GetList.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Category.ToString(), ObjectType.itemCount.ToString(), Categories.Value.Count));
            }

            if (Accounts.Value.Count > 0)
            {
                foreach (var dto in Accounts.Value)
                {
                    AccountService.DeleteAccountById(dto.Id);
                    addToOc(ActionsEnum.Delete.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Account.ToString(), ObjectType.itemId.ToString(), dto.Id));
                }

                Accounts = AccountService.GetAllAccounts(false, false);

                addToOc(ActionsEnum.GetList.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Account.ToString(), ObjectType.itemCount.ToString(), Accounts.Value.Count));
            }

            #endregion

            #region Ajout Category, Account

            var addedCategory = CategoryService.CreateCategory(newCategory);

            addToOc(ActionsEnum.Insert.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Category.ToString(), ObjectType.itemId.ToString(), addedCategory.Value.Id));


            var addedAccount = AccountService.CreateAccount(newAccount);

            addToOc(ActionsEnum.Insert.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Account.ToString(), ObjectType.itemId.ToString(), addedAccount.Value.Id));

            #endregion


            #region Ajout 2 transactions, same account, 1 with the category

            var newTransaction = new TransactionDto();
            newTransaction.Name = "First Transaction !";
            newTransaction.Balance = 40.0;
            newTransaction.Account = addedAccount.Value;
            newTransaction.Category = addedCategory.Value;

            var newTransaction2 = new TransactionDto();
            newTransaction2.Name = "Second Transaction !";
            newTransaction2.Balance = 40.0;
            newTransaction2.Account = addedAccount.Value;

            var addedtransaction = TransactionService.CreateTransaction(newTransaction);

            addToOc(ActionsEnum.Insert.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Transaction.ToString(), ObjectType.itemName.ToString(), addedtransaction.Value.Name));

            var addedtransaction2 = TransactionService.CreateTransaction(newTransaction);

            addToOc(ActionsEnum.Insert.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Transaction.ToString(), ObjectType.itemName.ToString(), addedtransaction2.Value.Name));

            #endregion

            #region get des listes par account et par category

            var listebyAccount = TransactionService.GetTransactionsByAccountId(addedAccount.Value.Id, false, false);

            addToOc(ActionsEnum.GetList.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Transaction.ToString(), ObjectType.itemCount.ToString(), listebyAccount.Value.Count));


           var listebyCategory = TransactionService.GetTransactionsByCategoryId(addedCategory.Value.Id, false, false);

           addToOc(ActionsEnum.GetList.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Transaction.ToString(), ObjectType.itemCount.ToString(), listebyCategory.Value.Count));

            #endregion

           var gettedTrans = TransactionService.GetTransactionById(addedtransaction.Value.Id, false, false).Value;

           addToOc(ActionsEnum.Get.ToString(), string.Format(TEMPLATEMessagedifferService, ServiceEnum.Transaction.ToString(), ObjectType.itemName.ToString(), gettedTrans.Name));


           gettedTrans.Name = "MODIFIED";

           var updatedCategory = TransactionService.UpdateTransaction(gettedTrans);

           addToOc(ActionsEnum.Update.ToString(), string.Format(TEMPLATEMessageOnUpdate, ServiceEnum.Transaction.ToString(), ObjectType.itemName.ToString(), updatedCategory.Value.Name, addedtransaction.Value.Name));

        }
Ejemplo n.º 13
0
        public static string GetTxDescription(TransactionDto tx, List <ChainDto> phantasmaChains, List <TokenDto> phantasmaTokens)
        {
            string description = null;

            string  senderToken   = null;
            Address senderChain   = Address.FromText(tx.ChainAddress);
            Address senderAddress = Address.Null;

            string  receiverToken   = null;
            Address receiverChain   = Address.Null;
            Address receiverAddress = Address.Null;

            BigInteger amount = 0;

            foreach (var evt in tx.Events) //todo move this
            {
                switch (evt.EventKind)
                {
                case EventKind.TokenSend:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount        = data.value;
                    senderAddress = Address.FromText(evt.EventAddress);
                    senderToken   = data.symbol;
                }
                break;

                case EventKind.TokenReceive:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount          = data.value;
                    receiverAddress = Address.FromText(evt.EventAddress);
                    receiverChain   = data.chainAddress;
                    receiverToken   = data.symbol;
                }
                break;

                case EventKind.TokenEscrow:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount = data.value;
                    var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == data.symbol).Decimals);
                    receiverAddress = Address.FromText(evt.EventAddress);
                    receiverChain   = data.chainAddress;
                    var chain = GetChainName(receiverChain.Text, phantasmaChains);
                    description =
                        $"{amountDecimal} {data.symbol} tokens escrowed for address {receiverAddress} in {chain}";
                }
                break;

                case EventKind.AddressRegister:
                {
                    var name = Serialization.Unserialize <string>(evt.Data.Decode());
                    description = $"{evt.EventAddress} registered the name '{name}'";
                }
                break;

                case EventKind.FriendAdd:
                {
                    var address = Serialization.Unserialize <Address>(evt.Data.Decode());
                    description = $"{evt.EventAddress} added '{address.ToString()} to friends.'";
                }
                break;

                case EventKind.FriendRemove:
                {
                    var address = Serialization.Unserialize <Address>(evt.Data.Decode());
                    description = $"{evt.EventAddress} removed '{address.ToString()} from friends.'";
                }
                break;
                }
            }

            if (description == null)
            {
                if (amount > 0 && senderAddress != Address.Null && receiverAddress != Address.Null &&
                    senderToken != null && senderToken == receiverToken)
                {
                    var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == senderToken).Decimals);

                    description =
                        $"{amountDecimal} {senderToken} sent from {senderAddress.ToString()} to {receiverAddress.ToString()}";
                }
                else if (amount > 0 && receiverAddress != Address.Null && receiverToken != null)
                {
                    var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == receiverToken).Decimals);

                    description = $"{amountDecimal} {receiverToken} received on {receiverAddress.Text} ";
                }
                else
                {
                    description = "Custom transaction";
                }

                if (receiverChain != Address.Null && receiverChain != senderChain)
                {
                    description +=
                        $" from {GetChainName(senderChain.Text, phantasmaChains)} chain to {GetChainName(receiverChain.Text, phantasmaChains)} chain";
                }
            }

            return(description);
        }
Ejemplo n.º 14
0
        public async Task <IActionResult> UpdateTransaction([FromBody] TransactionDto transaction)
        {
            var result = _extractService.UpdateTransaction(transaction);

            return(Response(result));
        }
Ejemplo n.º 15
0
 public static TransactionDto ToTransactionDto(this Transaction transaction) => new TransactionDto
 {
     Id      = transaction.TransactionIdentifier,
     Payment = $"{transaction.Amount} {transaction.CurrencyCode}",
     Status  = TransactionDto.GetStatus(transaction.Status)
 };
Ejemplo n.º 16
0
        public static string GetTxAmount(TransactionDto tx, List <ChainDto> phantasmaChains, List <TokenDto> phantasmaTokens)
        {
            string amountsymbol = null;

            string  senderToken   = null;
            Address senderChain   = Address.FromText(tx.ChainAddress);
            Address senderAddress = Address.Null;

            string  receiverToken   = null;
            string  receiverChain   = "";
            Address receiverAddress = Address.Null;

            BigInteger amount = 0;

            tx.Events.Reverse();
            foreach (var evt in tx.Events) //todo move this
            {
                switch (evt.EventKind)
                {
                case EventKind.TokenStake:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount          = data.Value;
                    receiverAddress = Address.FromText(evt.EventAddress);
                    receiverChain   = data.ChainName;
                    if (data.Symbol == "TTRS")
                    {
                        amountsymbol = $"{data.Symbol} • NFT";
                        break;
                    }
                    var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == data.Symbol).Decimals);
                    if (data.Symbol != "KCAL" && data.Symbol != "NEO" && data.Symbol != "GAS")
                    {
                        amountsymbol = $"{amountDecimal.ToString("#,0.##########").ToString(new CultureInfo("en-US"))} {data.Symbol}";
                    }
                }
                break;

                case EventKind.TokenClaim:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount          = data.Value;
                    receiverAddress = Address.FromText(evt.EventAddress);
                    receiverChain   = data.ChainName;
                    if (data.Symbol == "TTRS")
                    {
                        amountsymbol = $"{data.Symbol} • NFT";
                        break;
                    }
                    var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == data.Symbol).Decimals);
                    if (data.Symbol != "KCAL" && data.Symbol != "NEO" && data.Symbol != "GAS")
                    {
                        amountsymbol = $"{amountDecimal.ToString("#,0.##########").ToString(new CultureInfo("en-US"))} {data.Symbol}";
                    }
                }
                break;

                case EventKind.TokenSend:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount        = data.Value;
                    senderAddress = Address.FromText(evt.EventAddress);
                    senderToken   = data.Symbol;
                    if (data.Symbol == "TTRS")
                    {
                        amountsymbol = $"{data.Symbol} • NFT";
                        break;
                    }
                    var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == senderToken).Decimals);
                    amountsymbol = $"{amountDecimal.ToString("#,0.##########").ToString(new CultureInfo("en-US"))} {senderToken}";
                }
                break;

                case EventKind.TokenReceive:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount          = data.Value;
                    receiverAddress = Address.FromText(evt.EventAddress);
                    receiverChain   = data.ChainName;
                    receiverToken   = data.Symbol;
                    var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == receiverToken).Decimals);
                    if (data.Symbol == "TTRS")
                    {
                        amountsymbol = $"{data.Symbol} • NFT";
                        break;
                    }
                    amountsymbol = $"{amountDecimal.ToString("#,0.##########").ToString(new CultureInfo("en-US"))} {receiverToken}";
                }
                break;

                case EventKind.TokenMint:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount          = data.Value;
                    receiverAddress = Address.FromText(evt.EventAddress);
                    receiverChain   = data.ChainName;
                    var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == data.Symbol).Decimals);
                    amountsymbol = $"{amountDecimal.ToString("#,0.##########").ToString(new CultureInfo("en-US"))} {data.Symbol}";
                    if (data.Symbol == "TTRS")
                    {
                        amountsymbol = $"{data.Symbol} • NFT";
                    }
                }
                break;

                case EventKind.AddressRegister:
                {
                    return(amountsymbol = $"");
                }
                break;
                }
            }

            return(amountsymbol);
        }
Ejemplo n.º 17
0
        public static string GetTxType(TransactionDto tx, List <ChainDto> phantasmaChains, List <TokenDto> phantasmaTokens)
        {
            string typetx = null;

            string  senderToken   = null;
            string  senderChain   = phantasmaChains.Where(x => x.Address == tx.ChainAddress).Select(x => x.Name).FirstOrDefault();
            Address senderAddress = Address.Null;

            string  receiverToken   = null;
            string  receiverChain   = "";
            Address receiverAddress = Address.Null;

            BigInteger amount = 0;

            foreach (var evt in tx.Events)
            {
                switch (evt.EventKind)
                {
                case EventKind.ContractDeploy:
                {
                    return(typetx = $"Custom");
                }
                break;

                case EventKind.AddressRegister:
                {
                    return(typetx = $"Custom");
                }
                break;

                case EventKind.TokenClaim:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount = data.Value;
                    if (data.Symbol == "SOUL" || (data.Symbol == "KCAL" && amount >= 1000000000))
                    {
                        return(typetx = $"Custom");
                    }
                }
                break;

                case EventKind.TokenStake:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount = data.Value;
                    if (amount >= 1000000000)
                    {
                        if (data.Symbol != "KCAL" && data.Symbol != "NEO" && data.Symbol != "GAS")
                        {
                            //return typetx = $"Stake";
                            return(typetx = $"Custom");
                        }
                    }
                }
                break;

                case EventKind.TokenMint:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    if (data.Symbol == "TTRS" || data.Symbol == "GOATI")
                    {
                        return(typetx = $"Custom");
                    }
                    return(typetx = $"Mint");
                }
                break;

                case EventKind.TokenSend:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount        = data.Value;
                    senderAddress = Address.FromText(evt.EventAddress);
                    senderToken   = data.Symbol;
                }
                break;

                case EventKind.TokenReceive:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount          = data.Value;
                    receiverAddress = Address.FromText(evt.EventAddress);
                    receiverToken   = data.Symbol;
                }
                break;
                }
            }

            if (typetx == null)
            {
                if (amount > 0 && senderAddress != Address.Null && receiverAddress != Address.Null &&
                    senderToken != null && senderToken == receiverToken)
                {
                    typetx = $"{senderAddress.ToString()}";
                }
                else if (amount > 0 && receiverAddress != Address.Null && receiverToken != null)
                {
                    typetx = $"{receiverAddress.ToString()}";
                }
                else
                {
                    typetx = $"Custom";
                }
            }

            return(typetx);
        }
Ejemplo n.º 18
0
        public async Task <IActionResult> CreateTransaction(TransactionDto transDto)
        {
            if (transDto == null)
            {
                return(BadRequest(new ErrorModel(1, 400, "Empty Body")));
            }

            if (transDto.BusinessPlaceId == 0 || transDto.BusinessPlaceId == null)
            {
                return(BadRequest(new ErrorModel(2, 400, "Valid business place required")));
            }
            var place = await _context.BusinessPlaces.FirstOrDefaultAsync(a => a.Id == transDto.BusinessPlaceId);

            if (place == null)
            {
                return(BadRequest(new ErrorModel(2, 400, "Valid business place required")));
            }

            if (transDto.UserId == 0)
            {
                return(BadRequest(new ErrorModel(3, 400, "Valid user required")));
            }
            var userid = int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));

            if (transDto.UserId != userid)
            {
                return(BadRequest(new ErrorModel(3, 400, "Valid user required")));
            }

            if (transDto.Description == "" || (transDto.Debit == 0 && transDto.Credit == 0))
            {
                return(BadRequest(new ErrorModel(3, 400, "Empty values")));
            }

            var transToCreate = _mapper.Map <Transaction>(transDto);

            transToCreate.Date = DateTime.Today;

            var timeDate = DateTime.Now;

            transToCreate.Time = new TimeSpan(timeDate.Hour, timeDate.Minute, timeDate.Second);

            if (await _context.Transactions.AnyAsync(a => a.Reference.Contains(transToCreate.Reference) &&
                                                     a.Date == transToCreate.Date &&
                                                     a.BusinessPlaceId == transToCreate.BusinessPlaceId))
            {
                var transaction = await _context.Transactions.FirstOrDefaultAsync(a => a.Reference.Contains(transToCreate.Reference) &&
                                                                                  a.Date == transToCreate.Date &&
                                                                                  a.BusinessPlaceId == transToCreate.BusinessPlaceId);

                transaction.Debit  += transToCreate.Debit;
                transaction.Credit += transToCreate.Credit;
            }
            else
            {
                await _context.AddRangeAsync(transToCreate);
            }

            if (await _context.SaveChangesAsync() > 0)
            {
                return(Ok());
            }

            return(BadRequest(new ErrorModel(4, 400, "Failed to create transaction")));
        }
Ejemplo n.º 19
0
        public static string GetTxDescription(TransactionDto tx, List <ChainDto> phantasmaChains, List <TokenDto> phantasmaTokens, string addressfrom)
        {
            string description = null;

            string  senderToken   = null;
            string  senderChain   = phantasmaChains.Where(x => x.Address == tx.ChainAddress).Select(x => x.Name).FirstOrDefault();
            Address senderAddress = Address.Null;

            string  receiverToken   = null;
            string  receiverChain   = "";
            Address receiverAddress = Address.Null;

            BigInteger amount = 0;

            foreach (var evt in tx.Events)
            {
                switch (evt.EventKind)
                {
                case EventKind.TokenClaim:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    if (data.Symbol == "SOUL")
                    {
                        return(description = $"Custom transaction");
                    }
                }
                break;


                case EventKind.TokenStake:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount = data.Value;
                    if (amount >= 1000000000)
                    {
                        if (data.Symbol != "KCAL" && data.Symbol != "NEO" && data.Symbol != "GAS")
                        {
                            //return description = $"Stake transaction";
                            return(description = $"Custom transaction");
                        }
                    }
                }
                break;

                case EventKind.TokenMint:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    if (data.Symbol == "TTRS")
                    {
                        return(description = $"Custom transaction");
                    }
                    return(description = $"Claim transaction");
                }
                break;

                case EventKind.AddressRegister:
                {
                    var name = Serialization.Unserialize <string>(evt.Data.Decode());
                    description = $"Register transaction: name '{name}' registered";
                }
                break;

                case EventKind.TokenSend:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount        = data.Value;
                    senderAddress = Address.FromText(evt.EventAddress);
                    senderToken   = data.Symbol;
                }
                break;

                case EventKind.TokenReceive:
                {
                    var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
                    amount          = data.Value;
                    receiverAddress = Address.FromText(evt.EventAddress);
                    receiverChain   = data.ChainName;
                    receiverToken   = data.Symbol;
                }
                break;
                }
            }

            if (description == null)
            {
                if (amount > 0 && senderAddress != Address.Null && receiverAddress != Address.Null &&
                    senderToken != null && senderToken == receiverToken)
                {
                    var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == senderToken).Decimals);

                    if (addressfrom == senderAddress.ToString())
                    {
                        description =
                            $"Send transaction: to {receiverAddress.ToString()}";
                    }
                    else
                    {
                        description =
                            $"Receive transaction: from {senderAddress.ToString()}";
                    }
                }
                else if (amount > 0 && receiverAddress != Address.Null && receiverToken != null)
                {
                    var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == receiverToken).Decimals);

                    description = $"Send transaction: to {receiverAddress.Text} ";
                }
                else
                {
                    description = "Custom transaction";
                }
            }

            return(description);
        }
Ejemplo n.º 20
0
        public TransactionDto RegisterTransaction(TransactionParam param)
        {
            var result = new TransactionDto();

            result.Response = false;

            try
            {
                #region Validaciones

                if (param.IdBilletera < 0)
                {
                    result.Messages.Add(new Error()
                    {
                        Message = recurso.IdBilletera
                    });
                }

                if (param.IdTipoTransaccion < 0)
                {
                    result.Messages.Add(new Error()
                    {
                        Message = recurso.IdTransaccion
                    });
                }

                if (param.Monto == 0)
                {
                    result.Messages.Add(new Error()
                    {
                        Message = recurso.Monto
                    });
                }

                if (result.Messages.Count == 0)
                {
                    result.Response = true;
                    var     register = BDFile.LeeArchivo(recursoBD.UrlFile);
                    decimal balance  = 0;
                    if (!String.IsNullOrWhiteSpace(register))
                    {
                        balance = Convert.ToDecimal(register);
                    }

                    result.Amount = param.Monto;
                    _balance      = balance + param.Monto;
                    BDFile.EscribeEnArchivo(_balance.ToString(), recursoBD.UrlFile);
                    result.Balance = _balance;
                }


                #endregion
            }
            catch (Exception ex)
            {
                result.Messages.Add(new Error()
                {
                    Message = ex.Message
                });
            }
            return(result);
        }
Ejemplo n.º 21
0
 private string PrepareConfirmation(TransactionDto transactionDto)
 {
     return($"Thank you for your payment for transaction {transactionDto.Id} at {transactionDto.TransactionDate}. Your reservation number is {transactionDto.ReservationId}. You have to remeber this number!");
 }
Ejemplo n.º 22
0
 public Transaction(TransactionDto dto)
 {
     _dto = dto;
 }
Ejemplo n.º 23
0
        public ClientMessage <int> CreateLevel2Transaction(TransactionDto dto)
        {
            var       clientMessage = new ClientMessage <int>();
            const int correctScore  = 10;
            const int wrongScore    = 0;

            try
            {
                var transaction = _mapper.Map <Transaction>(dto);
                var player      = _dbContext.Players.FirstOrDefault(t => t.Id == dto.PlayerId);
                var question    = _questionServices.GetById(dto.QuestionId).ReturnedData;

                var answer = question.Answers.FirstOrDefault(t => t.Id == dto.AnswerId);

                if (player == null)
                {
                    clientMessage.ClientMessageContent = new List <string> {
                        "Error: Player id is not correct"
                    };
                    clientMessage.ReturnedData     = 0;
                    clientMessage.ClientStatusCode = DataEnum.OperationStatus.Error;
                    return(clientMessage);
                }
                if (question.Id == null || question.Id == 0)
                {
                    clientMessage.ClientMessageContent = new List <string> {
                        "Error: Question id is not correct"
                    };
                    clientMessage.ReturnedData     = 0;
                    clientMessage.ClientStatusCode = DataEnum.OperationStatus.Error;
                    return(clientMessage);
                }
                if (answer == null)
                {
                    clientMessage.ClientMessageContent = new List <string> {
                        "Error: Selected answer does not belong the the question"
                    };
                    clientMessage.ReturnedData     = 0;
                    clientMessage.ClientStatusCode = DataEnum.OperationStatus.Error;
                    return(clientMessage);
                }

                if (answer.IsCorrectAnswer)
                {
                    transaction.Score = correctScore.ToString();
                    if (int.TryParse(player.Score, out var playerScore))
                    {
                        playerScore += correctScore;
                        player.Score = playerScore.ToString();
                    }
                    else
                    {
                        player.Score = correctScore.ToString();
                    }
                }
                else
                {
                    transaction.Score = wrongScore.ToString();
                }

                transaction.CreatedById = -1;
                transaction.CreatedDate = DateTime.Now;
                transaction.IsActive    = true;
                _dbContext.Transactions.Add(transaction);
                _dbContext.SaveChanges();

                clientMessage.ClientMessageContent = new List <string> {
                    "Transaction created successfully"
                };
                clientMessage.ReturnedData     = transaction.Id;
                clientMessage.ClientStatusCode = DataEnum.OperationStatus.Ok;
                return(clientMessage);
            }
            catch (Exception ex)
            {
                clientMessage.ClientMessageContent = new List <string> {
                    ex.Message + " " + ex.InnerException
                };
                clientMessage.ReturnedData     = 0;
                clientMessage.ClientStatusCode = DataEnum.OperationStatus.Error;
                return(clientMessage);
            }
        }
Ejemplo n.º 24
0
        public static string GetTxDescription(TransactionDto tx, List <ChainDto> phantasmaChains, IList <TokenDto> phantasmaTokens)
        {
            string description = null;

            string  senderToken   = null;
            Address senderChain   = Address.FromText(tx.ChainAddress);
            Address senderAddress = Address.Null;

            string  receiverToken   = null;
            Address receiverChain   = Address.Null;
            Address receiverAddress = Address.Null;

            BigInteger amount = 0;

            foreach (var evt in tx.Events) //todo move this
            {
                Event nativeEvent;
                if (evt.Data != null)
                {
                    nativeEvent = new Event((Phantasma.Blockchain.Contracts.EventKind)evt.EventKind,
                                            Address.FromText(evt.EventAddress), evt.Data.Decode());
                }
                else
                {
                    nativeEvent =
                        new Event((Phantasma.Blockchain.Contracts.EventKind)evt.EventKind, Address.FromText(evt.EventAddress));
                }

                switch (evt.EventKind)
                {
                case Phantasma.RpcClient.DTOs.EventKind.TokenSend:
                {
                    var data = nativeEvent.GetContent <TokenEventData>();
                    amount        = data.value;
                    senderAddress = nativeEvent.Address;
                    senderToken   = (data.symbol);
                }
                break;

                case Phantasma.RpcClient.DTOs.EventKind.TokenReceive:
                {
                    var data = nativeEvent.GetContent <TokenEventData>();
                    amount          = data.value;
                    receiverAddress = nativeEvent.Address;
                    receiverChain   = data.chainAddress;
                    receiverToken   = data.symbol;
                }
                break;

                case Phantasma.RpcClient.DTOs.EventKind.TokenEscrow:
                {
                    var data = nativeEvent.GetContent <TokenEventData>();
                    amount = data.value;
                    var amountDecimal = UnitConversion.ToDecimal(amount,
                                                                 phantasmaTokens.SingleOrDefault(p => p.Symbol == data.symbol).Decimals);
                    receiverAddress = nativeEvent.Address;
                    receiverChain   = data.chainAddress;
                    var chain = GetChainName(receiverChain.Text, phantasmaChains);
                    description =
                        $"{amountDecimal} {data.symbol} tokens escrowed for address {receiverAddress} in {chain}";
                }
                break;

                case Phantasma.RpcClient.DTOs.EventKind.AddressRegister:
                {
                    var name = nativeEvent.GetContent <string>();
                    description = $"{nativeEvent.Address} registered the name '{name}'";
                }
                break;

                case Phantasma.RpcClient.DTOs.EventKind.AddFriend:
                {
                    var address = nativeEvent.GetContent <Address>();
                    description = $"{nativeEvent.Address} added '{address} to friends.'";
                }
                break;

                case Phantasma.RpcClient.DTOs.EventKind.RemoveFriend:
                {
                    var address = nativeEvent.GetContent <Address>();
                    description = $"{nativeEvent.Address} removed '{address} from friends.'";
                }
                break;
                }
            }

            if (description == null)
            {
                if (amount > 0 && senderAddress != Address.Null && receiverAddress != Address.Null &&
                    senderToken != null && senderToken == receiverToken)
                {
                    var amountDecimal = UnitConversion.ToDecimal(amount,
                                                                 phantasmaTokens.SingleOrDefault(p => p.Symbol == senderToken).Decimals);
                    description =
                        $"{amountDecimal} {senderToken} sent from {senderAddress.Text} to {receiverAddress.Text}";
                }
                else if (amount > 0 && receiverAddress != Address.Null && receiverToken != null)
                {
                    var amountDecimal = UnitConversion.ToDecimal(amount,
                                                                 phantasmaTokens.SingleOrDefault(p => p.Symbol == receiverToken).Decimals);
                    description = $"{amountDecimal} {receiverToken} received on {receiverAddress.Text} ";
                }
                else
                {
                    description = "Custom transaction";
                }

                if (receiverChain != Address.Null && receiverChain != senderChain)
                {
                    description +=
                        $" from {GetChainName(senderChain.Text, phantasmaChains)} chain to {GetChainName(receiverChain.Text, phantasmaChains)} chain";
                }
            }

            return(description);
        }
Ejemplo n.º 25
0
        private void createConditionalFPTree(List <FPPrefixPath> prefixPaths, ref List <ItemHeaderElement> itemHeaders)
        {
            foreach (FPPrefixPath p in prefixPaths)
            {
                for (int i = 0; i < p.support; i++)
                {
                    for (int j = 0; j < p.prefixpath.Count; j++)
                    {
                        Boolean found = false;
                        for (int k = 0; k < itemHeaders.Count; k++)
                        {
                            if (itemHeaders[k].itemID == p.prefixpath[j].item)
                            {
                                found = true;
                                itemHeaders[k].support = itemHeaders[k].support + 1;
                            }
                        }
                        if (!found)
                        {
                            itemHeaders.Add(new ItemHeaderElement(p.prefixpath[j].item, 1));
                        }
                    }
                }
            }


            /* remove the itemHeaders that don't meet min_sup */
            for (int n = 0; n < itemHeaders.Count; n++)
            {
                if (itemHeaders[n].support < min_sup)
                {
                    itemHeaders.RemoveAt(n--);
                }
            }


            /*
             * Console.WriteLine("ConditionalHeaderTable wo/node-links");
             * foreach (ItemHeaderElement e in itemHeaders)
             * {
             *  Console.WriteLine(e.ToString());
             * }
             * Console.WriteLine("Press any key to continue...");
             * Console.ReadKey();
             */


            /* remove prefixpath nodes that don't meet min_sup */
            foreach (FPPrefixPath p in prefixPaths)
            {
                List <int> removeList = new List <int>();
                p.prefixpath.Reverse();
                for (int i = 0; i < p.prefixpath.Count; i++)
                {
                    bool found = false;
                    for (int j = 0; j < itemHeaders.Count; j++)
                    {
                        if (itemHeaders[j].itemID == p.prefixpath[i].item)
                        {
                            found = true;
                        }
                    }
                    if (!found)
                    {
                        removeList.Add(i);
                    }
                }
                for (int i = 0; i < removeList.Count; i++)
                {
                    p.prefixpath.RemoveAt(removeList[i] - i); //CAN: Added because indexes change after the removing an element.  Did not encounter this issue in testing
                }
            }



            FPNode root = new FPNode(null, 0);

            foreach (FPPrefixPath p in prefixPaths)
            {
                TransactionDto dto = new TransactionDto();
                foreach (FPNode fpn in p.prefixpath)
                {
                    dto.items.Add(fpn.item);
                }

                /*
                 * Console.WriteLine("Adding to the tree " + p.support + " times: ");
                 * Console.WriteLine(dto);
                 * Console.ReadKey();
                 */
                for (int i = 0; i < p.support; i++)
                {
                    TransactionDto tmpDto = new TransactionDto();
                    foreach (string item in dto.items)
                    {
                        tmpDto.items.Add(item);
                    }
                    addToTree(ref root, tmpDto, ref itemHeaders);
                }
            }



            /*
             * Console.WriteLine("ConditionalHeaderTable w/node-links");
             * foreach (ItemHeaderElement e in itemHeaders)
             * {
             *  Console.WriteLine(e.ToString());
             * }
             * Console.WriteLine("Press any key to continue...");
             * Console.ReadKey();
             *
             * Console.WriteLine("Conditional FP-Tree children");
             * foreach (FPNode aNode in root.children)
             * {
             *  Console.WriteLine("----");
             *  FPNode myNode = aNode;
             *  while (myNode != null)
             *  {
             *      Console.WriteLine(myNode.item + ":" + myNode.support + " --> ");
             *      if (myNode.children.Count == 0) myNode = null;
             *      else myNode = myNode.children[0];
             *  }
             * }
             * Console.WriteLine("Press any key to continue...");
             * Console.ReadKey();
             */
        }
        public TransactionDto ExecuteTransaction(Transaction trans)
        {
            if (trans == null)
            {
                return(null);
            }

            var transDto = new TransactionDto();

            Account toAccount   = trans.ToAccount == null ? null : _accountRespository.GetById(trans.ToAccount.ID);
            Account fromAccount = trans.FromAccount == null ? null : _accountRespository.GetById(trans.FromAccount.ID);

            try
            {
                string        connectionString = "Server = localhost; Database = BankingApplication; Trusted_Connection = True; ";
                SqlConnection conn             = new SqlConnection(connectionString);
                conn.Open();

                switch (trans.Type)
                {
                case TransactionType.Deposit:
                    string validateMsg = ValidateDepositTransaction(trans);
                    if (!string.IsNullOrEmpty(validateMsg))
                    {
                        transDto.Errors.Add("DepositTransaction", validateMsg);
                        return(transDto);
                    }
                    toAccount.Balance += trans.Amount;

                    break;

                case TransactionType.Withdraw:
                    validateMsg = ValidateWithdrawTransaction(trans);
                    if (!string.IsNullOrEmpty(validateMsg))
                    {
                        transDto.Errors.Add("WithdrawTransaction", validateMsg);
                        return(transDto);
                    }
                    fromAccount.Balance -= trans.Amount;

                    break;

                case TransactionType.Transfer:
                    validateMsg = ValidateTransferTransaction(trans);
                    if (!string.IsNullOrEmpty(validateMsg))
                    {
                        transDto.Errors.Add("TransferTransaction", validateMsg);
                        return(transDto);
                    }
                    fromAccount.Balance -= trans.Amount;
                    toAccount.Balance   += trans.Amount;

                    break;

                default: return(null);
                }

                trans.FromAccount = fromAccount;
                trans.ToAccount   = toAccount;
                trans.Status      = TransactionStatus.Success;

                if (toAccount != null)
                {
                    toAccount.RowVersion = trans.ToAccount.RowVersion;
                }
                if (fromAccount != null)
                {
                    fromAccount.RowVersion = trans.FromAccount.RowVersion;
                }

                _transactionRespository.SaveTransaction(trans);
            }

            catch (DBConcurrencyException ex)
            {
                throw ex;
            }
            transDto.Transaction = trans;
            return(transDto);
        }
Ejemplo n.º 27
0
        public (string response, bool isSuccess) MakeTransaction(AddressService addressService, IHttpRequestService httpRequestService, NodeData nodeData, TransactionDto dto)
        {
            var response  = string.Empty;
            var isSuccess = false;

            if (addressService == null || httpRequestService == null || dto == null)
            {
                return(response, isSuccess);
            }

            // from + to + value
            var message = dto.Account + dto.ReceiverAccount + dto.TransferAmount;

            var publicKey = addressService.ToPublicKey(dto.PrivateKey);

            var signature   = addressService.SignData(message, dto.PrivateKey);
            var isSignValid = addressService.VerifySignature(publicKey, signature, message);

            if (!isSignValid)
            {
                return(response, isSuccess);
            }

            var signatureAsString = addressService.ByteToHex(signature);
            var publicKeyAsString = addressService.GetPublicKey(publicKey);

            var transaction = this.CreateTransactionModel(dto, signatureAsString, publicKeyAsString);

            (response, isSuccess) = this.SendTransaction(transaction, httpRequestService, nodeData);

            return(response, isSuccess);
        }
Ejemplo n.º 28
0
        public async Task <ActionResult> Create([FromBody] TransactionDto transactionDto)
        {
            var result = await _currencyConverterService.CurrencyConverterAsync(transactionDto);

            return(Ok(result));
        }
Ejemplo n.º 29
0
        public TransactionsDetailsViewModel(IPageService pageService, IRepository repository, TransactionDto transactionDto)
        {
            this.pageService = pageService;
            this.repository  = repository;
            CheckIfCategoriesAndAccountsExistsAsync().ContinueWith(r =>
            {
                var result = r.Result;
                if (!result)
                {
                    return;
                }
                prepareViewModel(transactionDto);
            }, TaskScheduler.FromCurrentSynchronizationContext());

            SaveCommand             = new Command(async x => await Save());
            IncomeSelectedCommand   = new Command(IncomeSelected);
            ExpenseSelectedCommand  = new Command(ExpenseSelected);
            SelectedAccountCommand  = new Command(async x => await SelectedAccount());
            SelectedCategoryCommand = new Command(async x => await SelectedCategory());
        }
Ejemplo n.º 30
0
 public static bool Delete(TransactionDto dto)
 {
     return(TransactionDao.Delete(dto.TransactionId));
 }
Ejemplo n.º 31
0
        public TransactionDto UpdateTransaction(TransactionDto transactionDto)
        {
            var objectToSave = MapFromDtoToDataObject(transactionDto);

            return(MapFromDataObjectToDto(_transactionRepository.UpdateTransaction(objectToSave)));
        }
Ejemplo n.º 32
0
        public async Task <ActionResult> CompleteTransaction([FromBody] TransactionDto transactionDto)
        {
            var transaction = await service.CompleteTransaction(transactionDto);

            return(Ok(transaction));
        }