public TransactionDTO <MessageDTO> CreateBet(CreateBetDTO createBet) { TransactionDTO <MessageDTO> transaction = new TransactionDTO <MessageDTO>(); transaction.Data = new MessageDTO(); try { long createRouletteId = _betRepository.CreateBet(createBet); if (createRouletteId < 0) { transaction.Status = Common.Status.Failure; transaction.Message = "No fue posible crear la apuesta de juego."; return(transaction); } transaction.Data.Message = "¡Apuesta aceptada! :)"; transaction.Data.Flag = true; } catch (ArgumentException ex) { transaction.Status = Common.Status.Failure; transaction.Message = ex.Message; } return(transaction); }
public void Create(TransactionDTO transaction) { using (var dbctx = new ExpenseTrackerEntities()) { var tran = new Transaction { TransactionAmount = transaction.TransactionAmount, TransactionDate = transaction.TransactionDate, TransactionNote = transaction.TransactionNote, CategoryId = transaction.CategoryId, UserId = transaction.UserId }; if (transaction.TransactionReceipts != null && transaction.TransactionReceipts.Any()) { transaction.TransactionReceipts.ToList().ForEach(t => { tran.TransactionReceipts.Add(new TransactionReceipt { ReceiptImage = t.ReceiptImage, ContentType = t.ContentType }); }); } dbctx.Transactions.Add(tran); dbctx.SaveChanges(); } }
public async Task <long> Save(TransactionDTO entity) { //using (DbTransaction transaction = _context.Database.BeginTransaction()) //{ try { if (entity.Id > 0) { _ISEDITMODE = true; } long transactionId = await _transactionDAL.Save(_mapper.Map <Transaction>(entity)); entity.Id = transactionId; long incomeId = await SaveIncome(entity); long transferId = await SaveTransfer(entity); long selectorId = await SaveSelector(entity); long reaperId = await SaveReaper(entity); long outcomeId = await SaveOutcome(entity); //transaction.Commit(); } catch (Exception ex) { //transaction.Rollback(); Console.WriteLine("Error occurred."); } // } return(1); }
private async Task <long> SaveOutcome(TransactionDTO entity) { OutcomeDTO outcome = new OutcomeDTO() { Date = entity.Date, CartNumber = entity.CartNumber, CategoryId = entity.CategoryId, DriverId = entity.DriverId, FarmId = entity.FarmId, Quantity = entity.ClientQuantity, KiloDiscount = entity.ClientDiscount, Total = entity.ClientTotal, KiloPrice = entity.ClientPrice, StationId = entity.StationId, TransactionId = entity.Id }; if (_ISEDITMODE)//Edit Mode { var oldOutcome = await GetOutcomtByTransactionId(entity.Id); outcome.Id = oldOutcome.Id; } return(await _outcomeDSL.Save(outcome)); }
private void button_Click(object sender, RoutedEventArgs e) { string categoryName = combobox.SelectedItem.ToString(); var product = _managerT.GetAllProduct().Where(p => p.Id == Id).FirstOrDefault(); if (product == null) { product = new ProductDTO(); } product.Name = nameBox.Text; product.Price = Convert.ToInt32(priceBox.Text); product.Description = descriptionBox.Text; product.CountInStock = Convert.ToInt32(countBox.Text); product.TimeOfAdd = DateTime.Now; var category = _managerT.GetAllCategories().Where(c => c.Name == categoryName).FirstOrDefault(); product.Category = category; _managerP.UpdateProduct(product); UserDTO cUser = _managerT.GetUserById(App.Id); TransactionDTO transaction = new TransactionDTO() { Product = product.Name, User = cUser.FirstName + " " + cUser.LastName, Status = "AddProduct", Time = DateTime.Now, TimeOfChange = DateTime.Now }; _managerT.AddTansaction(transaction); }
private bool AppendToStream(string Endpoint, string TempFilePath, TransactionDTO Transaction) { bool Result = false; try { var Request = WebRequest.Create($"{Endpoint}/{Transaction.ResponseMessage.Name}") as FtpWebRequest; Request.Method = WebRequestMethods.Ftp.UploadFile; using (var FileStream = System.IO.File.OpenRead(TempFilePath)) { using (var FtpStream = Request.GetRequestStream()) { FileStream.CopyTo(FtpStream); Result = true; } } } catch (Exception ex) { Transaction.ResponseMessage.Error.Reason = $"Message couldn't be sent: {ex.Message}"; } return(Result); }
/// <summary> /// Open specific transfer transaction to edit. /// </summary> /// <param name="transaction">Transaction to edit.</param> public void Edit(TransactionDTO transaction) { transactionId = transaction.Id; // Todo: refactor this method! var accountsSource1 = accounts1CollectionViewSource.Source as BindableCollection <AccountDTO>; if (accountsSource1 != null) { var selectedAccount1 = accountsSource1.Where(a => a.Id == transaction.Postings[1].Account.Id).Single(); Accounts1.MoveCurrentTo(selectedAccount1); } var accountsSource2 = accounts2CollectionViewSource.Source as BindableCollection <AccountDTO>; if (accountsSource2 != null) { var selectedAccount2 = accountsSource2.Where(a => a.Id == transaction.Postings[0].Account.Id).Single(); Accounts2.MoveCurrentTo(selectedAccount2); } OperationDate = transaction.Postings[0].Date.ToLocalTime(); Amount = transaction.Postings[0].Amount.ToString(); Comment = transaction.Comment; IsEditMode = true; }
public TransactionDTO <bool> CreateRouletteConfiguration(long rouletteId) { TransactionDTO <bool> transaction = new TransactionDTO <bool>(); transaction.Data = false; try { List <RouletteConfigurationModel> listRouletteConfiguration = _rouletteConfigurationRepository.GetAllRouletteConfigurationByRoulette(rouletteId); if (listRouletteConfiguration.Count > 0) { transaction.Status = Common.Status.Failure; transaction.Message = "Ya existen registro activos de la configuración de la ruleta."; return(transaction); } _rouletteConfigurationRepository.CreateRouletteConfiguration(rouletteId); transaction.Data = true; } catch (ArgumentException ex) { transaction.Status = Common.Status.Failure; transaction.Message = ex.Message; } return(transaction); }
public async Task <ActionResult <TransactionDTO> > UpdateTransaction1([FromBody] TransactionDTO trans) { var oldTrans = await TB.GetTransaction(trans.Id); var newTrans = mapper.Map <Transaction>(trans); var curStatus = TB.GetTransactionStatusName((int)oldTrans.CurrentStatus); if (oldTrans.CurrentStatus == (int)TransactionStatusEnum.Request || oldTrans.CurrentStatus == (int)TransactionStatusEnum.Rejected || newTrans.CurrentStatus == (int)TransactionStatusEnum.RequestReturn) { try { // keep exist status, status can't be edited when update newTrans.CurrentStatus = oldTrans.CurrentStatus; return(Ok(mapper.Map <TransactionDTO>(await TB.UpdateTransaction(newTrans)))); } catch (Exception ex) { return(BadRequest(ex.Message)); } } else { return(BadRequest($"Current status is {curStatus}, can't be updated")); } }
/// <summary> /// Method to get all the records from the BetType table /// </summary> /// <returns> Object with the transaction information </returns> public TransactionDTO <List <BetTypeDTO> > GetAllBetType() { TransactionDTO <List <BetTypeDTO> > transaction = new TransactionDTO <List <BetTypeDTO> >(); transaction.Data = new List <BetTypeDTO>(); try { var getDocumentType = _betTypeRepository.GetAllBetType(); if (getDocumentType == null || getDocumentType.Count == 0) { transaction.Status = Common.Status.Failure; transaction.Message = "No existen datos en la base de datos para los tipos de apuestas."; return(transaction); } foreach (var item in getDocumentType) { BetTypeDTO betTypeDTO = new BetTypeDTO(item.Id, item.Name, item.Code, item.Description, item.Pay); transaction.Data.Add(betTypeDTO); } } catch (ArgumentException ex) { transaction.Status = Common.Status.Failure; transaction.Message = ex.Message; } return(transaction); }
public TransactionStatusModel AddTransaction(TransactionDTO transaction) { TransactionStatusModel transStatus = new TransactionStatusModel(); using (SqlConnection con = new SqlConnection(cs)) { try { SqlCommand cmd = new SqlCommand("AddTransaction", con); cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.Add(new SqlParameter("@transactionId", transaction.TransactionId)); cmd.Parameters.Add(new SqlParameter("@userId", transaction.UserId)); cmd.Parameters.Add(new SqlParameter("@datetime", transaction.DateTime)); cmd.Parameters.Add(new SqlParameter("@totalPrice", transaction.TotalPrice)); con.Open(); cmd.ExecuteNonQuery(); } catch (Exception ex) { transStatus.ReturnMessage.Add("Add Transaction failed"); transStatus.ReturnStatus = false; return(transStatus); } } transStatus.ReturnMessage.Add("Transaction successfully added"); transStatus.ReturnStatus = true; return(transStatus); }
public async Task <uint> SaveTransaction(TransactionDTO transaction) { if (transaction.CodeTransactionID <= 0) { throw new Exception($"[{nameof(SaveTransaction)}] {nameof(TransactionDTO.CodeTransactionID)} is mandatory"); } if (transaction.TypeTransactionID <= 0) { throw new Exception($"[{nameof(SaveTransaction)}] {nameof(TransactionDTO.TypeTransactionID)} is mandatory"); } var newTransaction = new TransactionOutlay() { Amount = transaction.Amount, DateTransaction = transaction.Date.ToString(DATE_FORMAT), Description = transaction.Description, CodeTransaction_ID = transaction.CodeTransactionID, TypeTransaction_ID = transaction.TypeTransactionID }; await _contextDB.TransactionOutlay.AddAsync(newTransaction); await _contextDB.Context.SaveChangesAsync(); //load by ref the ID given by the DB transaction.ID = (uint)newTransaction.ID; ClearCacheTransactions(); return(transaction.ID); }
public async Task <TransactionDTO> UpdateTransaction(TransactionDTO transaction) { TransactionOutlay transactionToUpdate = (from TransactionOutlay t in _contextDB.TransactionOutlay .Include(x => x.TypeTransaction) .Include(x => x.CodeTransaction) where t.ID == transaction.ID select t).SingleOrDefault(); if (transactionToUpdate == null) { throw new Exception($"[{nameof(UpdateTransaction)}] Requested transaction not exist in DB. ID:{transaction.ID}"); } transactionToUpdate.Amount = transaction.Amount; transactionToUpdate.DateTransaction = transaction.Date.ToString(DATE_FORMAT); transactionToUpdate.CodeTransaction_ID = transaction.CodeTransactionID; transactionToUpdate.Description = transaction.Description; transactionToUpdate.TypeTransaction_ID = transaction.TypeTransactionID; await _contextDB.Context.SaveChangesAsync(); ClearCacheTransactions(); return(transactionToUpdate.ToTransactionDTO()); }
private async Task AddTransactionAsync(TransactionDTO transaction, BatchDTO batch) { var prefix = "[AddTransactionAsync]"; try { var category = await _categoryService.GetByNameAsync(transaction.Category.Name); if (category == null) { batch.Failed += 1; _logger.LogWarning($"{prefix} Unable to find category with name {transaction.Category.Name}"); } else { transaction.BatchID = batch.ID; transaction.Category = category; transaction = await _transactionService.AddAsync(transaction); _logger.LogInformation($"{prefix} Successfully added transaction with id {transaction.ID} to batch"); batch.Added += 1; } } catch (Exception ex) { _logger.LogError($"{prefix} {ex.GetType().Name} exception while adding transaction to batch"); _logger.LogError(ex.StackTrace); batch.Failed += 1; } }
public TransactionDTO Post([FromBody] TransactionDTO transactionDTO) { Transaction trans = new Transaction(); if (ModelState.IsValid) { if (transactionDTO.CardId is null) { trans = new Transaction() { Number = transactionDTO.Number, Amount = transactionDTO.Amount, Card = new Card() { Number = transactionDTO.CardNumber.ToString(), CardBrand = transactionDTO.CardBrand, CardholderName = transactionDTO.CardholderName, CVS = transactionDTO.CVS, CardType = transactionDTO.CardType, ExpirationDate = transactionDTO.ExpirationDate } }; } } else if (transactionDTO.CardId != null) { trans = new Transaction() { Number = transactionDTO.Number, Amount = transactionDTO.Amount, Card = new Card() { Id = Guid.Parse(transactionDTO.CardId) } }; } try { _TransactionBusiness.SaveAndUpdate(trans); _TransactionBusiness.Save(); transactionDTO.TransactionId = trans.Id; transactionDTO.TypeTransaction = trans.TypeTransaction; TelemetryService.TraceTransactionSave(JsonConvert.SerializeObject(transactionDTO)); } catch (Exception ex) { TelemetryService.TraceException(ex, JsonConvert.SerializeObject(transactionDTO)); throw new System.Web.Http.HttpResponseException(System.Net.HttpStatusCode.InternalServerError); } return(transactionDTO); }
public void AddNormal() { var transaction = new TransactionDTO { DT = new DateTime(2019, 01, 10, 12, 30, 41), Payee = new UserDTO { Id = 1, Balance = 100 }, Recepient = new UserDTO { Id = 2, Balance = 0 }, Amount = 10 }; _mockUserRepository.Setup(x => x.Get(transaction.Payee.Id)).Returns(transaction.Payee); _mockUserRepository.Setup(x => x.Get(transaction.Recepient.Id)).Returns(transaction.Recepient); using (var container = _builder.Build()) { var transactionService = container.Resolve <ITransactionService>(); transactionService.Add(transaction.DT, transaction.Payee.Id, transaction.Recepient.Id, transaction.Amount); } _mockUserRepository.Verify(x => x.Get(It.IsAny <int>()), Times.Exactly(2)); _mockUserRepository.Verify(x => x.Get(transaction.Payee.Id), Times.Once()); _mockUserRepository.Verify(x => x.Get(transaction.Recepient.Id), Times.Once()); _mockTransactionRepository.Verify(x => x.Add(transaction.DT, transaction.Payee.Id, transaction.Recepient.Id, transaction.Amount), Times.Once()); Assert.AreEqual(transaction.Payee.Balance, 90); Assert.AreEqual(transaction.Recepient.Balance, 10); }
public TransactionResult AgilePayment(string customerId, string title, TransactionDTO transaction, string language) { var transactionResult = new TransactionResult(false, ""); IHasBalances debitProduct = helper.GetProduct(transaction.DebitProductType, transaction.DebitProductId, out transactionResult, language); transactionResult = transferServices.CheckDebitBalance(debitProduct, transaction.Amount, language); IHasInstallment productForPayment = (IHasInstallment)helper.GetProduct(transaction.CreditProductType, transaction.CreditProductId, out transactionResult, language); if (!transactionResult.HasError) { transactionResult = CheckDebt(productForPayment, transaction.Amount, language); if (!transactionResult.HasError) { Payment(debitProduct, productForPayment, transaction.Amount, transaction.Expenses); transactionResult = helper.UpdateProduct(transaction.CreditProductType, (IHasBalances)productForPayment, language); if (!transactionResult.HasError) { transactionResult = helper.UpdateProduct(transaction.DebitProductType, debitProduct, language); if (!transactionResult.HasError) { transactionServices.LogTransaction(customerId, title, debitProduct.AvailableBalance, transaction); } } } } return(transactionResult); }
/// <summary> /// method to get the type of bet by the code of the bet /// </summary> /// <param name="code"> bet code </param> /// <returns> Object with the transaction information </returns> public TransactionDTO <BetTypeDTO> GetBetTypeByCode(string code) { TransactionDTO <BetTypeDTO> transaction = new TransactionDTO <BetTypeDTO>(); transaction.Data = new BetTypeDTO(); try { var getBetTypeByCode = _betTypeRepository.GetBetTypeByCode(code); if (getBetTypeByCode.Id == 0) { transaction.Status = Common.Status.Failure; transaction.Message = "No existen datos en la base de datos el tipo de apuesta escodigo."; return(transaction); } transaction.Data.Id = getBetTypeByCode.Id; transaction.Data.Name = getBetTypeByCode.Name; transaction.Data.Description = getBetTypeByCode.Description; transaction.Data.Pay = getBetTypeByCode.Pay; } catch (ArgumentException ex) { transaction.Status = Common.Status.Failure; transaction.Message = ex.Message; } return(transaction); }
public TransactionResult PrepaidCardLoad(string customerId, TransactionDTO transaction, string language) { TransactionResult transactionResult = new TransactionResult(false, ""); IHasBalances debitProduct = helper.GetProduct(transaction.DebitProductType, transaction.DebitProductId, out transactionResult, language); transactionResult = transferServices.CheckDebitBalance(debitProduct, transaction.Amount, language); if (!transactionResult.HasError) { var prepaidCard = cardServices.GetPrePaidCardById(transaction.CreditProductId, out transactionResult, language); if (!transactionResult.HasError) { transferServices.DebitProduct(debitProduct, transaction.Amount, transaction.Expenses); LoadPrepaidCard(prepaidCard, transaction.Amount); transactionResult = helper.UpdateProduct(transaction.DebitProductType, debitProduct, language); if (!transactionResult.HasError) { transactionResult = cardServices.UpdatePrepaidCard(prepaidCard, language); if (!transactionResult.HasError) { transactionServices.LogTransaction(customerId, "ΦΟΡΤΙΣΗ ΠΡΟΠΛ. ΚΑΡΤΑΣ", debitProduct.AvailableBalance, transaction); } } } } return(transactionResult); }
public static List <SpObject> AddTransactionConverter(TransactionDTO request) { return(new List <SpObject> { new SpObject { Name = senderId, value = request.SenderId, ParamType = MySqlDbType.VarChar }, new SpObject { Name = senderId, value = request.ReceiverId, ParamType = MySqlDbType.VarChar }, new SpObject { Name = senderId, value = request.Date.ToString(), ParamType = MySqlDbType.DateTime }, new SpObject { Name = amount, value = request.Amount.ToString(), ParamType = MySqlDbType.Int32 }, new SpObject { Name = senderId, value = request.BlockchainNumber.ToString(), ParamType = MySqlDbType.Int32 } }); }
public long SaveTransaction(Transaction transaction, string userId) { long transactionTypeId = 0; var transactionSubtype = _transactionSubTypeService.GetTransactionSubType(transaction.TransactionSubTypeId); if (transactionSubtype != null) { transactionTypeId = transactionSubtype.TransactionTypeId; } var transactionDTO = new TransactionDTO() { BranchId = transaction.BranchId, SectorId = transaction.SectorId, Amount = transaction.Amount, TransactionSubTypeId = transaction.TransactionSubTypeId, TransactionTypeId = transactionTypeId, CreatedOn = DateTime.Now, TimeStamp = DateTime.Now, CreatedBy = userId, Deleted = false, }; var transactionId = this._dataService.SaveTransaction(transactionDTO, userId); return(transactionId); }
public async Task Get_AllTransactions() { var transactions = await _client.GetAsync("/Transaction"); var data = JsonConvert.DeserializeObject <List <Transaction> > ( (await transactions.Content.ReadAsStringAsync()) ); Assert.Equal(HttpStatusCode.OK, transactions.StatusCode); var expectedFirstTransaction = new TransactionDTO() { Value = 1700, TransactionType = TransactionType.Deposit, Description = "Description Deposit", AccountId = 1 }; var firstData = data.FirstOrDefault(); Assert.Equal(expectedFirstTransaction.Value, firstData.Value); Assert.Equal(expectedFirstTransaction.TransactionType, firstData.TransactionType); Assert.Equal(expectedFirstTransaction.Description, firstData.Description); Assert.Equal(expectedFirstTransaction.AccountId, firstData.AccountId); }
public TransactionDTO <List <RouletteConfigurationDTO> > GetAllRouletteConfiguration() { TransactionDTO <List <RouletteConfigurationDTO> > transaction = new TransactionDTO <List <RouletteConfigurationDTO> >(); transaction.Data = new List <RouletteConfigurationDTO>(); try { var getAllRouletteConfigurationByRoullete = _rouletteConfigurationRepository.GetAllRouletteConfiguration(); if (getAllRouletteConfigurationByRoullete == null || getAllRouletteConfigurationByRoullete.Count == 0) { transaction.Status = Common.Status.Failure; transaction.Message = "No fue posible obtener los registros de la configuración de la ruleta ruletas."; return(transaction); } foreach (var item in getAllRouletteConfigurationByRoullete) { RouletteConfigurationDTO rouletteConfiguration = new RouletteConfigurationDTO(); rouletteConfiguration.Id = item.Id; rouletteConfiguration.Number = item.Number; rouletteConfiguration.Color = item.Color; rouletteConfiguration.Code = item.Code; rouletteConfiguration.RouletteId = item.RouletteId; transaction.Data.Add(rouletteConfiguration); } } catch (ArgumentException ex) { transaction.Status = Common.Status.Failure; transaction.Message = ex.Message; } return(transaction); }
public async Task Get_TransactionById() { var transactionId = 1; var transaction = await _client.GetAsync(String.Format("/Transaction/{0}", transactionId)); var data = JsonConvert.DeserializeObject <TransactionDTO> ( (await transaction.Content.ReadAsStringAsync()) ); Assert.Equal(HttpStatusCode.OK, transaction.StatusCode); var expectedTransaction = new TransactionDTO() { Value = 1700, TransactionType = TransactionType.Deposit, Description = "Description Deposit", AccountId = 1 }; Assert.Equal(expectedTransaction.Value, data.Value); Assert.Equal(expectedTransaction.TransactionType, data.TransactionType); Assert.Equal(expectedTransaction.Description, data.Description); Assert.Equal(expectedTransaction.AccountId, data.AccountId); }
public void Post([FromBody] TransactionDTO model) { var transaction = mapper.Map <Transaction>(model); _context.Transactions.Add(transaction); _context.SaveChanges(); }
public IActionResult CreatePrimaryCheckingDeposit([FromBody] TransactionDTO transaction) { try { if (BankAccountValidation.VerifyInputForDeposit(_logger, transaction) == false) { return(BadRequest("The deposit type is not known")); } //note: wrapping the uow into a using block to approximate true data access against a DB, per best practices using (IUnitOfWork uow = new UnitOfWork()) { var acctFactory = new AccountFactory(); var primaryChecking = acctFactory.CreateInstance(AccountTypeEnum.PrimaryChecking); IAccountManager acctMgr = new AccountManager(primaryChecking, uow); var transactionEntity = Mapper.Map <Transaction>(transaction); acctMgr.RecordDepositOrWithdrawal(transactionEntity); return(StatusCode(201)); } } catch (Exception ex) { _logger.LogCritical($"Exception thrown in the AccountController. Message details: {ex.Message}"); return(StatusCode(500, "An error was detected in the Account Controller. View message log for details.")); } }
public bool SendData(string Endpoint, TransactionDTO Transaction) { var Result = false; string TempFilePath = Path.Combine(Path.GetTempPath(), Transaction.ResponseMessage.Name); try { using (var FileStream = new StreamWriter(TempFilePath)) { FileStream.WriteLine(Transaction.ResponseMessage.Content); } } catch (Exception ex) { Transaction.ResponseMessage.Error.Reason = $"Temp message couldn't be created: {ex.Message}"; } if (System.IO.File.Exists(TempFilePath)) { Result = this.AppendToStream(Endpoint, TempFilePath, Transaction); if (Result) { System.IO.File.Delete(TempFilePath); } } return(Result); }
public decimal InsertTransaction(TransactionDTO model) { try { SqlCommand cmd = new SqlCommand(); cmd.Connection = conn; cmd.CommandType = CommandType.StoredProcedure; cmd.CommandText = "wallet.sp_insertTransaction"; cmd.Parameters.Clear(); cmd.Parameters.AddWithValue("@Amount", model.Amount); cmd.Parameters.AddWithValue("@CreateDate", DateTime.Now); cmd.Parameters.AddWithValue("@stcode", CleanString(model.stcode)); cmd.Parameters.AddWithValue("@CurrentBalance", model.CurrentBalance); cmd.Parameters.AddWithValue("@Description", (object)CleanString(model.Description) ?? DBNull.Value); cmd.Parameters.AddWithValue("@TransactionTypeId", model.TransactionTypeId); var dt = new DataTable(); conn.Open(); SqlDataReader rdr; rdr = cmd.ExecuteReader(); dt.Load(rdr); conn.Close(); if (dt.Rows.Count > 0) { return(Convert.ToDecimal(dt.Rows[0][0])); } else { return(0); } } catch (Exception x) { return(0); } }
public async Task <ActionResult> Put(int id, [FromBody] TransactionDTO transactionDTO) { if (transactionDTO.Id != id) { return(BadRequest("Id doesn't match")); } try { bool result = await _transService.EditAsync(id, transactionDTO); if (result) { return(Ok()); } else { return(BadRequest()); } } catch { return(StatusCode(500)); } }
public async Task <TransactionDTO> GameTransaction(User user, int amount, string game, string description, TransactionType type) { var wallet = await this.context.Wallets.FirstOrDefaultAsync(k => k.User == user); var rates = await this.foreignExchangeService.GetConvertionRates(); var convertedAmount = Math.Round(amount / rates.Rates[wallet.Currency.ToString()], 2); var transaction = new Transaction() { Type = type, Description = description + game, User = user, Amount = convertedAmount, CreatedOn = dateTimeProvider.Now, Currency = wallet.Currency }; this.context.Transactions.Add(transaction); await this.context.SaveChangesAsync(); var transactionDTO = new TransactionDTO(transaction); return(transactionDTO); }
public bool Transfer(Guid ticket, int from, int to, decimal ammount, string[] tags) { // Validar o ticket if (!ValidateTicket(ticket)) { return false; } using(DataAccessLayer dal = new EFDataAccessLayer()) { using (TransactionScope tr = new TransactionScope()) { //obter as contas AccountDTO fromAccount = dal.AccountDAO.Read(from); AccountDTO toAccount = dal.AccountDAO.Read(to); //transferir o dinheiro fromAccount.Value -= ammount; toAccount.Value += ammount; //guardar 1Centimo para a caridade fromAccount.Value -= VALOR_CONTRIBUICAO; // adicinar o centimo à conta da organização solidaria // Adicionar transacçao - isto vai demorar longitudes de tempo... uma msmq a fazer isto é melhor ////TODO Falta acabar isto TransactionDTO tranOCW = new TransactionDTO(0,ammount, VALOR_CONTRIBUICAO, DateTime.Now, 0,0,0); dal.TransactionDAO.Create(tranOCW); // fazer update a tudo dal.AccountDAO.Update(fromAccount); dal.AccountDAO.Update(toAccount); tr.Complete(); } } return true; }
public override List<TransactionDTO> GetTransactions(int accountID) { _accountIDParm = accountID; var myParm = _accountIDParm.ToString(CultureInfo.InvariantCulture); var getAccountTransactions = MMSQLGetTransactionsByID + myParm; if (myData.GetConnection(out _myAccessConn)) return null; try { using (var myAccessCommand = new OleDbCommand(getAccountTransactions, _myAccessConn)) { _myAccessConn.Open(); using (var dr = new SafeDataReader(myAccessCommand.ExecuteReader())) using (dr) while (dr.Read()) { var myTransactionDTO = new TransactionDTO { TransactionID = dr.GetInt32(dr.GetOrdinal("TransactionID")), AccountID = dr.GetInt32(dr.GetOrdinal("CustomerID")), TransactionDate = dr.GetSmartDate(dr.GetOrdinal("TransDate")), Amount = dr.GetDecimal(dr.GetOrdinal("Amount")), Description = dr.GetString(dr.GetOrdinal("Description")), TransactionCode = dr.GetString(dr.GetOrdinal("TranCode")), UnitID = dr.GetInt32(dr.GetOrdinal("UnitID")), RentalDate = dr.GetSmartDate(dr.GetOrdinal("RentalDate")) }; mytransactionDTOs.Add(myTransactionDTO); } } return mytransactionDTOs; } catch (Exception ex) { Console.WriteLine("Error: Failed to retrieve the required data from the DataBase.\n{0}", ex.Message); return null; } finally { _myAccessConn.Close(); } }