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); } } } }
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)); }
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)); }
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); } }
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); }
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!")); } }
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)); }
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) { } }
public static async Task PublishUserDepositCanceledIntegrationEventAsync(this IServiceBusPublisher publisher, UserId userId, TransactionDto transaction) { var integrationEvent = new UserDepositCanceledIntegrationEvent { UserId = userId, Transaction = transaction }; await publisher.PublishAsync(integrationEvent); }
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)); }
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); }
public async Task <IActionResult> UpdateTransaction([FromBody] TransactionDto transaction) { var result = _extractService.UpdateTransaction(transaction); return(Response(result)); }
public static TransactionDto ToTransactionDto(this Transaction transaction) => new TransactionDto { Id = transaction.TransactionIdentifier, Payment = $"{transaction.Amount} {transaction.CurrencyCode}", Status = TransactionDto.GetStatus(transaction.Status) };
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); }
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); }
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"))); }
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); }
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); }
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!"); }
public Transaction(TransactionDto dto) { _dto = dto; }
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); } }
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); }
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); }
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); }
public async Task <ActionResult> Create([FromBody] TransactionDto transactionDto) { var result = await _currencyConverterService.CurrencyConverterAsync(transactionDto); return(Ok(result)); }
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()); }
public static bool Delete(TransactionDto dto) { return(TransactionDao.Delete(dto.TransactionId)); }
public TransactionDto UpdateTransaction(TransactionDto transactionDto) { var objectToSave = MapFromDtoToDataObject(transactionDto); return(MapFromDataObjectToDto(_transactionRepository.UpdateTransaction(objectToSave))); }
public async Task <ActionResult> CompleteTransaction([FromBody] TransactionDto transactionDto) { var transaction = await service.CompleteTransaction(transactionDto); return(Ok(transaction)); }