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();
}
}
