public IActionResult FundsPayment([FromBody] JObject paymentInfoObject)
{
var walletId = paymentInfoObject["walletId"].ToObject <int>();
var fundsToGrant = paymentInfoObject["fundsToGrant"].ToObject <double>();
var wereFundsGranted = _walletRepository.FundsPayment(walletId, fundsToGrant);
if (!wereFundsGranted)
{
return(NotFound());
}
_transactionRepository.AddTransaction(walletId, fundsToGrant, TransactionType.Payment);
return(Ok(true));
}
public void AddTransaction_Errors()
{
try
{
Transaction transaction = repo.GetTransactions().FirstOrDefault();
repo.AddTransaction(transaction);
}
catch (Exception ex)
{
Logger.LogException(ex);
Assert.IsTrue(ex.Message == "Catch me!");
}
}
public void GetTransactions_All_Success()
{
//arrange
EFDbContext context = new EFDbContext(CreateNewContextOptions());
TransactionRepository transactionRepository = new TransactionRepository(context);
//act
var transactions = new List <Transaction>
{
new Transaction {
TransactionId = 1,
TransactionDate = new DateTime(2019, 11, 12),
Items = new List <Item>()
},
new Transaction {
TransactionId = 2,
TransactionDate = new DateTime(2018, 11, 12),
Items = new List <Item>()
},
new Transaction {
TransactionId = 3,
TransactionDate = new DateTime(2017, 11, 12),
Items = new List <Item>()
},
};
transactions.ForEach(t => transactionRepository.AddTransaction(t));
var result = transactionRepository.GetTransactions();
//asserts
Assert.NotNull(result);
}
public void AddTransaction_CorrectTransaction_Success()
{
//arrange
EFDbContext context = new EFDbContext(CreateNewContextOptions());
TransactionRepository transactionRepository = new TransactionRepository(context);
ItemRepository itemRepository = new ItemRepository(context);
Item item = new Item
{
Name = "ooo",
PurchasePrice = 888,
Quantity = 8
};
Item item2 = new Item
{
ItemId = 1,
Name = "AAA",
PurchasePrice = 888,
Quantity = 8
};
Transaction transaction = new Transaction
{
Items = new List <Item> {
item, item2
},
};
Transaction transaction2 = new Transaction
{
Items = new List <Item> {
item2
}
};
//act
transactionRepository.AddTransaction(transaction);
transactionRepository.AddTransaction(transaction2);
var all = transactionRepository.GetTransactions();
//asserts
Assert.AreEqual(2, all.Count);
}
public ActionResult AddTransaction(int id, int quantity)
{
if ((ModelState.IsValid && quantity != 0))
{
_transactionsRepostiory.AddTransaction(id, quantity);
}
return(RedirectToAction("Detail", new { id = id }));
}
public void AddTransaction_Null_NullArgException()
{
//arrange
EFDbContext context = new EFDbContext(CreateNewContextOptions());
TransactionRepository transactionRepository = new TransactionRepository(context);
//act and assert
Assert.Throws <ArgumentNullException>(() => { transactionRepository.AddTransaction(null); });
}
public void AddTransaction()
{
decimal amount = 500;
int userId = 1;
TransactionRepository transactionRepository = new TransactionRepository();
Transaction transaction = transactionRepository.AddTransaction(userId, amount);
Assert.IsNotNull(transaction, "Add transaction is returning a null object.");
Assert.IsTrue(transaction.Amount == amount, "Added Transaction amount does not match.");
Assert.IsTrue(transaction.UserId == userId, "Added Transaction user id does not match.");
// Reversing the transaction ensures that it doesn't interfere with any other unit tests
Transaction reverseTransaction = transactionRepository.AddTransaction(userId, amount * -1);
Assert.IsNotNull(reverseTransaction, "Add transaction is returning a null object.");
Assert.IsTrue(reverseTransaction.Amount == amount * -1, "Added Transaction amount does not match.");
Assert.IsTrue(reverseTransaction.UserId == userId, "Added Transaction user id does not match.");
}
public virtual IActionResult AddTransaction([FromBody] Transaction transaction)
{
var result = _transactionRepository.AddTransaction(transaction);
if (result == null)
{
return(BadRequest());
}
return(new ObjectResult(result));
}
public long AddTransaction(TransactionObject transaction)
{
try
{
return(_transactionRepository.AddTransaction(transaction));
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public void Add_A_transaction()
{
// Arrange
DateTime now = DateTime.Now;
Transaction transaction = new Transaction(200, now);
// Act
_sut.AddTransaction(transaction);
// Assert
var actualTransaction = _sut.GetTransactions();
Assert.Single(actualTransaction);
Assert.Equal(200, actualTransaction[0].Amount);
Assert.Equal(now, actualTransaction[0].Date);
}
protected async Task ExecuteAsync(CancellationToken stoppingToken)
{
// This will cause the loop to stop if the service is stopped
while (!stoppingToken.IsCancellationRequested)
{
var transactionRepository = new TransactionRepository();
var transactions = await transactionRepository.Get(x =>
(x.AddedAt >= DateTime.Now.AddDays(-1) && x.AddedAt <= DateTime.Now && x.Validated == false) && (x.To == PaymentUserType.InternEON.ToString() || x.To == PaymentUserType.InternElectrica.ToString()));
var transactionPerProvider = new Dictionary <string, double>();
foreach (var transaction in transactions)
{
if (transactionPerProvider.ContainsKey(transaction.To))
{
transactionPerProvider[transaction.To] += transaction.Value;
}
else
{
transactionPerProvider[transaction.To] = transaction.Value;
}
await transactionRepository.ValidateTransaction(transaction);
}
foreach (var(key, value) in transactionPerProvider)
{
await transactionRepository.AddTransaction(new Transaction.API.Models.Transaction()
{
AddedAt = DateTime.Now,
From = PaymentUserType.App.ToString(),
InvoiceId = Guid.NewGuid().ToString(),
To = key.Replace("Intern", ""),
UserId = "App",
Validated = true,
Value = value
});
}
await Task.Delay(TimeSpan.FromMinutes(3), stoppingToken);
}
}
public void AddTransaction(int accountId)
{
Transaction transaction = new Transaction();
if (IsDeposit)
{
transaction = TransactionFactory.CreateTransaction(Ammount, $"deposit");
_transactionRepository.AddDeposit(transaction, accountId);
}
else if (IsWithdrawal)
{
transaction = TransactionFactory.CreateTransaction(Ammount, $"withdrawal");
_transactionRepository.AddWithdrawal(transaction, accountId);
}
else
{
transaction = TransactionFactory.CreateTransaction(Ammount, AccountOfRecipient, Vs, Ks, Ss, MessageForRecipient);
_transactionRepository.AddTransaction(transaction, accountId);
}
}
public ActionResult Create([Bind(Include = "Description,MonetaryAmount,AdditionalTimestamp")] TransactionViewModel tran)
{
if (ModelState.IsValid)
{
Transaction transaction = new Transaction()
{
MonetaryAmount = tran.MonetaryAmount,
Description = tran.Description,
AdditionalTimestamp = tran.AdditionalTimestamp,
EntryTimestamp = DateTime.Now,
TargetUserID = TempData["MemberID"].ToString(),
SubmitterID = TempData["UserID"].ToString(),
GroupID = (int)TempData["GroupID"]
};
_tranRepo.AddTransaction(transaction);
return(RedirectToAction("Index", "Transactions", new { memberId = TempData["MemberID"].ToString(), groupId = (int)TempData["GroupID"] }));
}
return(View());
}
private void BuatTransaksi()
{
if (TransactionViewModel.Pelanggan == "")
{
MessageBox.Show("Nama pelanggan kosong", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (TransactionViewModel.Total == 0)
{
MessageBox.Show("Tidak ada pembelian apapun", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
Mediator.Invoke("Update Next Invoice Number");
UpdateInvoiceNumber();
transactionRepo.AddTransaction(TransactionViewModel.Transaction);
TransactionViewModel.Transaction = transactionRepo.GenerateEmptyTransaction();
TransactionViewModel.Kasir = Auth.Instance.LoggedUser.Name;
MessageBox.Show("Transaksi disimpan", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
Mediator.Invoke("Update Next Invoice Number");
UpdateInvoiceNumber();
}
public bool TakeBook(Transaction transaction)
{
if (User.Identity.IsAuthenticated)
{
int bookQuantity = BookRepository.GetBookQuantity(transaction.BookId);
if (bookQuantity > 0)
{
BookRepository.UpdateBookQuantity(new int[] { transaction.BookId, bookQuantity - 1 });
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
UserStore userStore = new UserStore();
User user = userStore.FindByIdAsync(transaction.UserId).Result;
user.sendMail();
}).Start();
return(TransactionRepository.AddTransaction(transaction));
}
}
return(false);
}
public Transaction AddTransaction(Transaction transaction)
{
_repository.AddTransaction(transaction);
return(transaction);
}
public void Configure(IApplicationBuilder app, IAntiforgery antiforgery, IOptions <AntiforgeryOptions> options, IHostingEnvironment env, ILoggerFactory loggerFactory, TransactionRepository transactionRepository)
{
app.Use(next => context =>
{
if (
string.Equals(context.Request.Path.Value, "/", StringComparison.OrdinalIgnoreCase) ||
string.Equals(context.Request.Path.Value, "/index.html", StringComparison.OrdinalIgnoreCase))
{
// We can send the request token as a JavaScript-readable cookie, and Angular will use it by default.
var tokens = antiforgery.GetAndStoreTokens(context);
context.Response.Cookies.Append("XSRF-TOKEN", tokens.FormToken, new CookieOptions()
{
HttpOnly = false
});
}
return(next(context));
});
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
app.UseIISPlatformHandler();
app.UseDefaultFiles();
app.UseStaticFiles();
app.Map("/api/transaction", a => a.Run(async context =>
{
if (string.Equals("GET", context.Request.Method, StringComparison.OrdinalIgnoreCase))
{
var transactions = transactionRepository.GetTransactions();
await context.Response.WriteAsync(JsonConvert.SerializeObject(transactions, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}));
}
else if (string.Equals("POST", context.Request.Method, StringComparison.OrdinalIgnoreCase))
{
/* This code wont be needed in RC2 */
var dictionary = new Dictionary <string, StringValues>
{
{ options.Value.FormFieldName, context.Request.Headers["X-XSRF-TOKEN"] }
};
context.Request.Form = new FormCollection(dictionary);
/* =============================== */
await antiforgery.ValidateRequestAsync(context);
var serializer = new JsonSerializer();
using (var reader = new JsonTextReader(new StreamReader(context.Request.Body)))
{
var transaction = serializer.Deserialize <Transaction>(reader);
transactionRepository.AddTransaction(transaction);
}
context.Response.StatusCode = 204;
}
}));
}
private async void AddTransaction()
{
if (tbx_name.Text.Equals(""))
{
MessageBox.Show(Strings.ErrorEmptyName, Strings.Error);
return;
}
TransactionRepository transactionRepository = TransactionRepository.Instance;
transaction.Name = tbx_name.Text;
transaction.TypeName = cbx_type.Text;
transaction.Amount = nud_amount.Value;
transaction.CreatedDate = dtp_date.Value;
transaction.Note = rtbx_note.Text;
transaction.Type = transaction.TypeName.Equals("Income") ? true : false;
Contact contact = (Contact)cbx_contact.SelectedItem;
if (contact == null)
{
if (string.IsNullOrWhiteSpace(cbx_contact.Text))
{
transaction.ContactID = 0;
}
else
{
ContactRepository contactRepository = ContactRepository.Instance;
transaction.ContactID = contactRepository.AddContact(new Contact {
Name = cbx_contact.Text, UserID = Instances.User.ID
});
}
}
else
{
transaction.ContactID = contact.ID;
}
if (chbx_recurring.Checked && transaction.ID == 0)
{
RecurringTransaction temporaryRecurringTransaction = new RecurringTransaction
{
Name = transaction.Name,
Amount = transaction.Amount,
UserID = transaction.UserID,
Type = transaction.Type,
CreatedDate = transaction.CreatedDate,
Note = transaction.Note,
ContactID = transaction.ContactID
};
if (chbx_infinite.Checked)
{
temporaryRecurringTransaction.EndDate = DateTime.MinValue;
}
else
{
temporaryRecurringTransaction.EndDate = dtp_end_date.Value;
}
temporaryRecurringTransaction.Status = cbx_frequency.Text;
RecurringTransactionRepository recurringTransactionRepository = RecurringTransactionRepository.Instance;
bool i = await Task.Run(() => recurringTransactionRepository.AddTransaction(temporaryRecurringTransaction));
if (i == false)
{
MessageBox.Show(Strings.SomethingError, Strings.Error);
return;
}
}
bool result = false;
if (transaction.ID > 0)
{
result = await Task.Run(() => transactionRepository.EditTransaction(transaction));
}
else
{
result = await Task.Run(() => transactionRepository.AddTransaction(transaction));
}
if (transaction.ID > 0 && result)
{
MessageBox.Show(Strings.EditTransactionOkay, Strings.Success);
Dispose();
}
else if (result)
{
MessageBox.Show(Strings.AddTransactionOkay, Strings.Success);
Dispose();
}
else
{
MessageBox.Show(Strings.SomethingError, Strings.Error);
}
}
///<summary>
/// Creates a transaction in the ledger
///</summary>
public ServiceResponse CreateTransaction(int userId, decimal amount)
{
if (amount == 0)
{
Message invalidAmountMessage = new Message()
{
Text = "Please enter a valid amount.",
Type = MessageType.WARN,
};
return(new ServiceResponse()
{
Messages = new List <Message>()
{
invalidAmountMessage
},
});
}
try
{
ServiceResponse balanceResponse = GetAccountBalance(userId);
decimal balance = (decimal)balanceResponse.ResponseObject;
decimal newBalance = balance + amount;
if (newBalance >= 0)
{
Transaction newTransaction = transactionRepository.AddTransaction(userId, amount);
string actionType = amount > 0 ? "deposited" : "withdrawn";
Message successMessage = new Message()
{
Text = $"You have successfully {actionType} ${Math.Abs(amount)}. Your new balance is ${newBalance}.",
Type = MessageType.SUCCESS,
};
return(new ServiceResponse()
{
ResponseObject = newTransaction,
Messages = new List <Message>()
{
successMessage
},
});
}
else
{
Message insufficientFundsMessage = new Message()
{
Text = "You do not have sufficient funds to make this withdrawal. Please deposit more funds or withdraw a smaller amount.",
Type = MessageType.WARN,
};
return(new ServiceResponse()
{
Messages = new List <Message>()
{
insufficientFundsMessage
},
});
}
}
catch
{
Message errorMessage = new Message()
{
Text = "There was an error with your transaction. Please try again. If the error continues then please contact us at 123-456-7890.",
Type = MessageType.ERROR,
};
return(new ServiceResponse()
{
Messages = new List <Message>()
{
errorMessage
},
});
}
}
internal void AddTransition(string info, int productId)
{
Transaction transaction = new Transaction(info, productId);
transactionRepository.AddTransaction(transaction);
}
public IActionResult Insert([FromBody] Transaction transaction)
{
System.Console.WriteLine(transaction.ToJson());
repository.AddTransaction(transaction);
return(Created("", null));
}
private async void DoRecurringTransaction()
{
TransactionRepository transactionRepository = TransactionRepository.Instance;
RecurringTransactionRepository recurringTransactionRepository = RecurringTransactionRepository.Instance;
if (Instances.User == null)
{
return;
}
List <RecurringTransaction> recurringTransactions = recurringTransactionRepository.GetUserTransactions(Instances.User.ID);
foreach (RecurringTransaction recurringTransaction in recurringTransactions)
{
if (Instances.User == null)
{
return;
}
if (DateTime.Now > recurringTransaction.EndDate && recurringTransaction.EndDate != DateTime.MinValue)
{
continue;
}
DateTime accTime = Instances.User.LastAccessDate;
DateTime nowTime = DateTime.Now;
int days = (nowTime - accTime).Days;
DateTime recTime = Instances.User.LastAccessDate;
TimeSpan ts = new TimeSpan(
recurringTransaction.CreatedDate.Hour,
recurringTransaction.CreatedDate.Minute,
recurringTransaction.CreatedDate.Second
);
recTime = recTime.Date + ts;
for (int i = 0; i <= days; i++)
{
if (recurringTransaction.Status.Equals("Weekly"))
{
if (recTime.DayOfWeek != recurringTransaction.CreatedDate.DayOfWeek)
{
recTime = recTime.AddDays(1);
continue;
}
}
if (recurringTransaction.Status.Equals("Monthly"))
{
if (recTime.Day != recurringTransaction.CreatedDate.Day)
{
recTime = recTime.AddDays(1);
continue;
}
}
if (recurringTransaction.Status.Equals("Yearly"))
{
string recTimeString = recTime.ToString("dd/MM");
string createdDateString = recurringTransaction.CreatedDate.ToString("dd/MM");
if (!recTimeString.Equals(createdDateString))
{
recTime = recTime.AddDays(1);
continue;
}
}
if (recTime > accTime && recTime <= nowTime && recTime > recurringTransaction.CreatedDate)
{
if (Instances.User == null)
{
return;
}
await Task.Run(() => transactionRepository.AddTransaction(new Transaction
{
Name = recurringTransaction.Name,
UserID = recurringTransaction.UserID,
ContactID = recurringTransaction.ContactID,
Type = recurringTransaction.Type,
Amount = recurringTransaction.Amount,
Note = recurringTransaction.Note,
CreatedDate = recTime
}));
bw_recurring.ReportProgress(1, "New transaction has been added!");
}
recTime = recTime.AddDays(1);
}
}
}
