public async Task <IActionResult> Create([FromBody] TransactionVM dataVM)
{
var dataT = new TransactionVM
{
UserId = dataVM.UserId,
Total = dataVM.Total,
};
var create = _repo.Create(dataT);
if (create > 0)
{
var getTransactionId = _context.Transactions.Max(x => x.TransactionId);
foreach (TransactionItemVM ti in dataVM.transactionItems)
{
var getProductId = _context.Products.SingleOrDefault(x => x.ProductName == ti.ProductName);
var data = new TransactionItem
{
TransactionId = getTransactionId,
ProductId = getProductId.ProductId,
Quantity = ti.Quantity,
SubTotal = ti.SubTotal,
};
await _context.TransactionItems.AddAsync(data);
var getCart = _context.Carts.SingleOrDefault(x => x.ProductId == getProductId.ProductId && x.UserId == dataVM.UserId);
_context.Carts.Remove(getCart);
}
await _context.SaveChangesAsync();
return(Ok("Successfully Created"));
}
return(BadRequest("Input User Not Successfully"));
}
public IActionResult Checkout(long id)
{
var model = new TransactionVM
{
CourseId = id
};
var course = _context.Courses.FirstOrDefault(x => x.Id == model.CourseId);
var entity = new TransactionModel
{
Time = System.DateTime.Now,
CourseId = course.Id,
UserId = long.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier)),
Amount = course.Price ?? 0,
Status = "Pending"
};
_context.Add(entity);
_context.SaveChanges();
entity = _context.Transactions.Include(x => x.Course).Include(x => x.User).FirstOrDefault(x => x.Id == entity.Id);
var response = Services.GetAnAcceptPaymentPage.Run(entity, _settings, _urlHelper);
model.SessionToken = response.sessionToken;
model.Amount = entity.Amount;
return(View(model));
}
public async Task <string> AddUpdateUser(TransactionVM transactionVM)
{
TransactionDomainModel transactionDM = new TransactionDomainModel();
AutoMapper.Mapper.Map(transactionVM, transactionDM);
return(await transactionBusiness.AddUpdateTransaction(transactionDM));
}
// GET: Carts/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Cart cart = await db.Carts.FindAsync(id);
if (cart == null)
{
return(HttpNotFound());
}
CartVM cartVM = new CartVM(cart);
cartVM.TransactionVMs = TransactionVM.Transactions(cart.Transactions);
var list = db.UserRecords.OrderBy(u => u.HDBUserName).ToList();
cartVM.Buyers = new SelectList(list.Where(u => (u.UserType & UserRecord.UserTypes.Buyer) == UserRecord.UserTypes.Buyer), "Id", "HDBUserName");
cartVM.Sellers = new SelectList(list.Where(u => (u.UserType & UserRecord.UserTypes.Seller) == UserRecord.UserTypes.Seller), "Id", "HDBUserName");
ViewBag.BuyerId = cartVM.Buyers;
ViewBag.SellerId = cartVM.Sellers;
Session.Remove("Transactions");
Session.Add("Transactions", cartVM.TransactionVMs);
return(View(cartVM));
}
// add a transaction
// done
public static TransactionVM AddTran(TransactionVM t)
{
using (SA46Team08ADProjectContext entities = new SA46Team08ADProjectContext())
{
try
{
Transaction tran = new Transaction();
tran.TranDateTime = t.TranDateTime;
tran.ItemCode = t.ItemCode;
tran.QtyChange = t.QtyChange;
tran.UnitPrice = t.UnitPrice;
tran.Desc = t.Desc;
tran.DeptCode = t.DeptCode;
tran.SuppCode = t.SuppCode;
tran.VoucherNo = t.VoucherNo;
entities.Transactions.Add(tran);
entities.SaveChanges();
List <Transaction> translist = entities.Transactions.ToList();
int transId = translist[translist.Count - 1].TranId;
t.TranId = transId;
return(t);
}
catch (Exception ex)
{
throw ex;
}
}
}
/// <summary>
/// Creator : Jaeho Kim
/// Created: 3/05/2020
/// Approver: Rasha Mohammed
///
/// This method populates all of the products to the data grid.
/// </summary>
/// <remarks>
/// Updater: NA
/// Updated: NA
/// Update: NA
///
/// </remarks>
private void populateProductList()
{
_transactionVM = (TransactionVM)dgTransactionsList.SelectedItem;
int transactionID = _transactionVM.TransactionID;
dgProductList.ItemsSource = _transactionManager.RetrieveAllProductsByTransactionID(transactionID);
}
public async Task <IActionResult> TransferFund(TransactionVM transaction)
{
try
{
var destinationBankAccount = await _bankingService.GetBankAccountInfo(transaction.Perticulars);
if (destinationBankAccount == null)
{
return(BadRequest("bank account not exists."));
}
var sourceBankAccount = await _bankingService.GetBankAccountInfo(BankAccount.UserName);
if (sourceBankAccount.Balance <= 0)
{
return(BadRequest("You have insufficient balance."));
}
await _bankingService.TransferToAnotherAccount(sourceBankAccount, destinationBankAccount, transaction.Amount);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public TransactionCreatedVM AddTransaction(TransactionVM transaction)
{
var tr = _transactionService.Create(transaction);
tr.From = GetOrAddAddress(tr.From);
tr.To = GetOrAddAddress(tr.To);
var isValid = _transactionService.Validate(tr);
if (!isValid)
{
//throw?
}
if (_confirmedTransactionsById.ContainsKey(tr.TransactionHash))
{
throw new Exception($"Transaction['{tr.TransactionHash}'] already processed.");
}
if (!_pendingTransactionsById.ContainsKey(tr.TransactionHash))
{
_pendingTransactionsById.TryAdd(tr.TransactionHash, tr);
}
//TODO: Schedule notify peers
return(new TransactionCreatedVM
{
DateReceived = DateTime.UtcNow.ToString("o"),
TransactionHash = tr.TransactionHash
});
}
public IActionResult PurchaseReebux(TransactionVM transaction)
{
try
{
var user = userManager.GetUserAsync(HttpContext.User).Result;
var userwallet = walletService.GetWallets().Where(s => s.UserID == user.Id).FirstOrDefault();
var product = reebuxService.GetReebux(transaction.ReebuxID);
Transaction tr = new Transaction();
tr.Amount = transaction.Amount;
tr.Details = transaction.Details;
tr.IsValid = true;
tr.Method = transaction.Method;
tr.UserID = user.Id;
tr.WalletID = userwallet.Id;
tr.AddDate = DateTime.Now;
tr.Status = 1;
transactionService.InsertTransaction(tr);
userwallet.Balance += product.Balance;
walletService.UpdateWallet(userwallet);
return(Ok(new TransactionResponse {
Message = "Successfully deposited", IsSuccess = true
}));
}
catch (Exception ex)
{
return(Ok(new TransactionResponse {
Message = "Failed to deposited", IsSuccess = false
}));
}
}
public void CreateTransaction(TransactionVM transVm)
{
var transaction = new Transaction
{
SenderId = transVm.sender_id,
Name = transVm.name,
Type = transVm.type,
DateTime = transVm.date,
AmountOfRoommates = transVm.amount_of_users,
AmountTotal = transVm.amount_total
};
_context.Transactions.Add(transaction);
_context.SaveChanges();
decimal amountToReceiver;
//if (transVm.amount_of_users > 1)
//{
//get amount to receiver by dividing total-amount by amount-of-users + 1 sender
amountToReceiver = transVm.amount_total / (transVm.amount_of_users + 1);
//}else
//{
//amountToReceiver = transVm.amount_total;
//}
//if (transVm.type == "Bill")
//{
// amountToReceiver *= -1;
//}
foreach (string userId in transVm.receivers)
{
CreateRoommateTransaction(transaction.TransactionId,
userId, amountToReceiver);
}
}
public int Update(int id, TransactionVM transactionVM)
{
var Id = new SqlParameter("@Id", id);
var orderdate = new SqlParameter("@OrderDate", transactionVM.OrderDate);
return(myContext.Database.ExecuteSqlRaw("sp_UpdateDataTransaction @Id, @OrderDate", Id, orderdate));
}
public async Task <bool> Create(TransactionVM transactionVM, string username)
{
var user = await _userService.GetByUsername(username);
transactionVM.UserId = user.Id;
var transaction = _mapper.Map <Transaction>(transactionVM);
var account = await _accountService.GetById(transaction.AccountId);
if (transaction.TransactionType == TransactionType.Expence)
{
account.Balance -= transaction.Amount;
}
else
{
account.Balance += transaction.Amount;
}
await _accountService.Update(account);
if (!string.IsNullOrEmpty(transaction.BudgetId))
{
var budget = await _budgetService.GetById(transaction.BudgetId);
budget.Available -= transaction.Amount;
await _budgetService.Update(budget);
}
else if (!string.IsNullOrEmpty(transaction.GoalId))
{
var goal = await _goalService.GetById(transaction.GoalId);
goal.Remaining -= transaction.Amount;
await _goalService.Update(goal);
}
else if (!string.IsNullOrEmpty(transaction.RecurringPaymentId))
{
var payment = await _paymentService.GetById(transaction.RecurringPaymentId);
payment.Amount -= transaction.Amount;
await _paymentService.Update(payment);
}
else if (!string.IsNullOrEmpty(transaction.InvestmentId))
{
var investment = await _investmentService.GetById(transaction.InvestmentId);
if (transaction.TransactionType == TransactionType.Expence)
{
investment.Amount += transaction.Amount;
}
else
{
investment.Amount -= transaction.Amount;
}
await _investmentService.Update(investment);
}
return(await _transactionRepository.Create(transaction));
}
public int Create(TransactionVM transactionVM)
{
var push = new Transaction(transactionVM);
myContext.Transactions.Add(push);
return(myContext.SaveChanges());
//throw new NotImplementedException();
}
public int Compare(TransactionVM x, TransactionVM y)
{
if (x == null || y == null)
{
return(0);
}
return(y.Date.CompareTo(x.Date));
//return x.Date.CompareTo(y.Date);
}
public IActionResult HandleTransaction(TransactionVM transVM)
{
TransactionRepo transRepo = new TransactionRepo(_context);
transVM.amount_of_users = transVM.receivers.Count();
transRepo.CreateTransaction(transVM);
return(RedirectToAction("Profile"));
}
/// <summary>
/// Creator: Jaeho Kim
/// Created: 03/08/2020
/// Approver: Rasha Mohammed
///
/// Implementation for Selecting all transactions using a employee name.
/// </summary>
/// <remarks>
/// Updater: Robert Holmes
/// Updated: 04/24/2020
/// Update: Added CustomerEmail and StripeChargeID
/// </remarks>
/// <param name="firstName">the first name of the employee</param>
/// <param name="lastName">the last name of the employee</param>
/// <returns>returns a list of transactions</returns>
public List <TransactionVM> SelectTransactionsByEmployeeName(string firstName, string lastName)
{
List <TransactionVM> transactions = new List <TransactionVM>();
var conn = DBConnection.GetConnection();
var cmd = new SqlCommand("sp_select_transactions_by_employee_name", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("FirstName", firstName);
cmd.Parameters.AddWithValue("LastName", lastName);
try
{
conn.Open();
var reader = cmd.ExecuteReader();
while (reader.Read())
{
TransactionVM transactionVM = new TransactionVM();
transactionVM.TransactionID = reader.GetInt32(0);
transactionVM.TransactionDateTime = reader.GetDateTime(1);
transactionVM.EmployeeID = reader.GetInt32(2);
transactionVM.FirstName = reader.GetString(3);
transactionVM.LastName = reader.GetString(4);
transactionVM.TransactionTypeID = reader.GetString(5);
transactionVM.TransactionStatusID = reader.GetString(6);
transactionVM.TaxRate = reader.GetDecimal(7);
transactionVM.SubTotalTaxable = reader.GetDecimal(8);
transactionVM.SubTotal = reader.GetDecimal(9);
transactionVM.Total = reader.GetDecimal(10);
if (!reader.IsDBNull(11))
{
transactionVM.CustomerEmail = reader.GetString(11);
}
if (!reader.IsDBNull(12))
{
transactionVM.StripeChargeID = reader.GetString(12);
}
transactions.Add(transactionVM);
}
reader.Close();
}
catch (Exception ex)
{
throw ex;
}
finally
{
conn.Close();
}
return(transactions);
}
public async Task <IActionResult> Edit(int?id)
{
try
{
if (id == null)
{
return(NotFound());
}
var transaction = await _context.Transaction.FindAsync(id);
if (transaction == null)
{
return(NotFound());
}
if (_user == null)
{
_user = await _userManager.GetUserAsync(User);
}
List <Property> listofProperty = new List <Property>();
listofProperty = (_context.Property.Where(x => x.IsAvaliable == true && ((x.UserId == _user.UserName) || _user.IsAdmin == true)).ToList());
listofProperty.Insert(0, new Property {
PropertyId = 0, PropertyName = "select"
});
ViewBag.ListofavailableProduct = listofProperty;
ViewBag.SelectedProperty = transaction.PropertyId;
var model = new TransactionVM()
{
transaction = new Transaction()
{
UserId = transaction.UserId,
property = new Property()
{
PropertyId = transaction.PropertyId
},
PropertyId = transaction.PropertyId,
TransactionDate = transaction.TransactionDate,
TransactionId = transaction.TransactionId
}
};
return(View(model));
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
return(View(new ErrorViewModel {
RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier
}));
}
}
public void UpdateDataTables()
{
ContentsVM.UpdateDataList(SearchBar);
TransactionVM.UpdateDataList(SearchBar);
NewTransactionVM.UpdateDataList(SearchBar);
string commandText = "SELECT DISTINCT [Job number] FROM [Sheet1$] " +
"";
JobNumbers = DbContext.GetDataTable(commandText, searchBar);
}
public IActionResult Index()
{
List <Account> accounts = _repo.Accounts;
TransactionVM model = new TransactionVM()
{
Accounts = accounts
};
return(View(model));
}
public HttpResponseMessage AddTransaction(TransactionVM t)
{
TransactionVM transaction = TransactionBL.AddTran(t);
if (transaction == null)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
return(Request.CreateResponse(HttpStatusCode.OK, transaction));
}
public IActionResult Post(TransactionVM transactionVM)
{
var push = _transactionService.Create(transactionVM);
if (push > 0)
{
return(Ok("Successfully Added!"));
}
return(BadRequest("Added Row Failed!"));
}
public IActionResult Put(int id, TransactionVM transactionVM)
{
var put = _transactionService.Update(id, transactionVM);
if (put > 0)
{
return(Ok("Update Sucessed!"));
}
return(BadRequest("Update Role Failed!"));
}
public int Update(int Id, TransactionVM transactionVM)
{
var result = 0;
var update = myContext.Transactions.Find(Id);
update.Update(transactionVM);
result = myContext.SaveChanges();
return(result);
//throw new NotImplementedException();
}
// GET: Transaction
public ActionResult Index()
{
TransactionVM transactionVM = new TransactionVM();
if (!CheckSession())
{
return(RedirectToAction("Index", "Login"));
}
transactionVM.AccountHolderId = Convert.ToInt32(Session["account"]);
return(View(transactionVM));
}
public ActionResult Index(TransactionVM vm)
{
vm.AccountHolderId = Convert.ToInt32(Session["account"]);
BankingServices bankingService = new BankingServices(_dbContext);
AccountTransaction transaction = new AccountTransaction {
TransactionType = vm.SelectedType, TransactionAmount = vm.Amount, TransactionDate = DateTime.Now
};
bankingService.DoTransaction(transaction, vm.AccountHolderId);
return(View(vm));
}
public ActionResult Index(TransactionVM vm)
{
vm.LoggedInAccountNo = Convert.ToInt32(Session["acntno"]);
BankingServices bankService = new BankingServices(_dbContext);
AccountTransaction acntTransaction = new AccountTransaction {
TransactionType = vm.SeletedTransactionType, TransactionAmount = vm.TransactionAmount, TransactionDate = DateTime.Now, acnt = bankService.GetLoggedInAccount(vm.LoggedInAccountNo)
};
bankService.DoTransaction(acntTransaction, vm.LoggedInAccountNo);
return(View(vm));
}
public int Create(TransactionVM dataVM)
{
using (SqlConnection connection = new SqlConnection(_configuration.GetConnectionString("myConn")))
{
var procName = "SP_Transaction_Create";
parameters.Add("UserId", dataVM.UserId);
parameters.Add("OrderDate", DateTimeOffset.Now);
parameters.Add("Total", dataVM.Total);
var insert = connection.Execute(procName, parameters, commandType: CommandType.StoredProcedure);
return(insert);
}
}
public ActionResult TransactionDialogContents()
{
int id = 0;
TransactionVM tr = new TransactionVM();
if (Int32.TryParse(Request.Params["Id"], out id))
{
TransactionRecord user = db.TransactionRecords.SingleOrDefault(u => u.Id == id);
if (user != null)
{
tr = new TransactionVM(user);
}
int nItems = int.Parse(Request["nItems"]);
double iAmount = double.Parse(Request["iAmount"]);
double sAmount = double.Parse(Request["sAmount"]);
var transactions = Session["Transactions"] as List <TransactionVM>;
if (transactions != null)
{
nItems -= transactions.Sum(t => t.NumItems);
iAmount -= transactions.Sum(t => t.ItemsTotal);
sAmount -= transactions.Sum(t => t.ShippingTotal);
}
tr.NumItems = nItems;
tr.ItemsTotal = iAmount;
tr.ShippingTotal = sAmount;
}
else
{
Guid g = Guid.Empty;
if (Guid.TryParse(Request.Params["Id"], out g))
{
var transactions = Session["Transactions"] as List <TransactionVM>;
if (transactions != null)
{
var item = transactions.Find(i => i.Id == g);
if (item != null)
{
tr = item;
tr.UpdateTargetId = string.Format("XAct{0}", tr.Id);
}
}
}
}
var list = db.UserRecords.OrderBy(u => u.HDBUserName).ToList();
tr.Sellers = new SelectList(list.Where(u => (u.UserType & UserRecord.UserTypes.Seller) == UserRecord.UserTypes.Seller), "Id", "HDBUserName");
var pv = PartialView("_TransactionDlg", tr);
return(pv);
}
public async Task <IActionResult> Edit(TransactionVM transactionVM)
{
if (!ModelState.IsValid)
{
AddModelErrors(ModelState);
return(View(transactionVM));
}
await _transactionService.Update(transactionVM);
return(RedirectToAction(nameof(All))
.WithSuccess("Успех!", "Променте са запазени."));
}
public TransactionVM GetTransactionInfo(string transactionHash)
{
_pendingTransactionsById.TryGetValue(transactionHash, out var transaction);
if (transaction == null)
{
_confirmedTransactionsById.TryGetValue(transactionHash, out transaction);
}
var vm = TransactionVM.FromModel(transaction);
return(vm);
}
