private async void PostValue()
{
double amount = ApplicationVM.ActiveUser.Balance + TotalAmount;
CustomerTransaction ct = new CustomerTransaction()
{
RijksregisterNummer = ApplicationVM.ActiveUser.RijksregisterNummer, VerschilBedrag = amount
};
string input = JsonConvert.SerializeObject(ct);
using (HttpClient client = new HttpClient())
{
client.SetBearerToken(ApplicationVM.Token.AccessToken);
HttpResponseMessage response = await client.PostAsync("http://localhost:3655/api/customertransaction/", new StringContent(input, Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
ApplicationVM appvm = App.Current.MainWindow.DataContext as ApplicationVM;
ApplicationVM.ActiveUser.Balance = amount;
appvm.ChangePage(new MainscreenVM());
}
else
{
Error = "Transactie mislukt";
CreateErrorlog(Error, "OpladenVM", "PostValue");
}
}
}
public async Task <IActionResult> Edit(decimal id, [Bind("CUSTOMERID,TRANSACTIONDATE,EMPLOYEEID,AMOUNT,DESCRIPTION,REFERENCE,id")] CustomerTransaction customerTransaction)
{
if (id != customerTransaction.id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(customerTransaction);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomerTransactionExists(customerTransaction.id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(customerTransaction));
}
public async Task <IHttpActionResult> Post(CustomerTransaction item)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
item.ObjectState = ObjectState.Added;
_service.Insert(item);
try
{
await _unitOfWorkAsync.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (ItemExists(item.CustomerTransactionID))
{
return(Conflict());
}
throw;
}
return(Created(item));
}
public HttpResponseMessage Get([FromUri] CustomerTransaction transaction)
{
var restrequest = new RestRequest("customertransaction/getTransactions", ContentMediaType.Json);
restrequest.AddQueryStringParameters(new QueryStringParameter {
Name = "fromDate", Value = transaction.FromDate.ToString("yyyy-MM-dd")
});
restrequest.AddQueryStringParameters(new QueryStringParameter {
Name = "toDate", Value = transaction.ToDate.ToString("yyyy-MM-dd")
});
restrequest.AddQueryStringParameters(new QueryStringParameter {
Name = "transactionStatus", Value = transaction.TransactionStatus
});
restrequest.AddQueryStringParameters(new QueryStringParameter {
Name = "customerId", Value = transaction.CustomerId.ToString()
});
var trans = this.restClient.GetData <ApiResponse <List <CustomerTransaction> > >(restrequest);
if (trans.Item1.Status)
{
return(Request.CreateResponse(HttpStatusCode.OK, trans.Item1.DataModel));
}
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "We are experience some technical error. Please try again later."));
}
public HttpResponseMessage Post(CustomerTransaction ct)
{
ClaimsPrincipal p = RequestContext.Principal as ClaimsPrincipal;
CustomerDA.LowerBalance(ct.VerschilBedrag, ct.RijksregisterNummer, p.Claims);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
public async Task <ActionResult> Create([Bind(Include = "AccountNum,Amount,TransactionType,Description")] CustomerTransaction ctrans)
{
//If model-state is valid, record data hidden from User
//Create Entry, Save DB changes
if (ModelState.IsValid)
{
/* MESSED UP BY NO LONGER HAVING USERID
* var uid = User.Identity.GetUserId();
* ctrans.UserID = uid.ToString();
* ctrans.TransactionDate = DateTime.Now;
*
* //THIS TWO LINES ARE FOR TESTING, AND SHOULD BE ERASED
* //ONCE THE DB AUTO INC'S TransactionID
* Random random = new Random();
* ctrans.TransactionID = random.Next(0, Int32.MaxValue-1);
*
*
* db.CustomerTransactions.Add(ctrans);
*
* //STUB: Add Logic updating whichever account the transaction is applied to here.
*
* await db.SaveChangesAsync();
*/
return(RedirectToAction("Index", "CustomerTransaction"));
}
return(View(ctrans));
}
public void Submit(string name, string cc, string address, string exp, string cvv, string city, string state, string zip, string phone, string insurance)
{
CreditCard card = new CreditCard();
card.CardNumber = cc;
card.CVV = int.Parse(cvv);
card.ExpMonth = int.Parse(exp.Substring(0, 2)); //1st and 2nd character
card.ExpYear = int.Parse(exp.Substring(3, 2)); //3rd and 4th character
CustomerTransaction trans = new CustomerTransaction();
trans.Address = address;
trans.Card = card;
trans.InsuranceNumber = insurance;
trans.Name = name;
trans.PhoneNumber = phone;
Rental r = new Rental();
r.CustInfo = trans;
r.Vehicle = mVehicle;
r.RentalStart = DateTime.Today;
DBConnector.StoreRental(r);
Form f = new HomepageAgent(account);
f.Show();
}
public async Task <CustomerTransaction> CreateCustomerTransaction(CustomerTransaction customerTransaction)
{
var result = await _db.CustomerTransaction.AddAsync(customerTransaction);
await _db.SaveChangesAsync();
return(result.Entity);
}
public ActionResult DeleteConfirmed(int id)
{
CustomerTransaction customerTransaction = db.CustomerTransaction.Find(id);
db.CustomerTransaction.Remove(customerTransaction);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <CustomerTransaction> UpdateCustomerTransaction(int id, CustomerTransaction customerTransaction)
{
_db.Entry(customerTransaction).State = EntityState.Modified;
await _db.SaveChangesAsync();
var result = await _db.CustomerTransaction.FirstOrDefaultAsync(x => x.Id == id);
return(result);
}
public ActionResult Edit([Bind(Include = "ID,TransactionTypeId,BankerId,AccountId,Amount")] CustomerTransaction customerTransaction)
{
if (ModelState.IsValid)
{
db.Entry(customerTransaction).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(customerTransaction));
}
public static Rental getRental(string License)
{
//retrieve the relevant rental rows that match the license
string command = "SELECT r.rentalID, r.rentalDate, r.transID, r.vehicleID FROM Rental as r, Vehicle as v WHERE v.vehicleID = r.vehicleID AND v.licenseNum = @License";
SqlCommand cmd = new SqlCommand(command);
cmd.Parameters.Add("@License", SqlDbType.VarChar, 50);
cmd.Parameters["@License"].Value = License;
object[] items = SafeQuery(cmd);
Rental r = new Rental();
r.RentalStart = (DateTime)items[1];
int transID = (int)items[2];
int vehID = (int)items[3];
//retrieve the vehicle object from the given vehicleID
command = "SELECT * FROM Vehicle WHERE vehicleID = " + vehID;
items = Query(command);
Vehicle v = new Vehicle((string)items[1], (string)items[2], (string)items[3], (int)items[4], (string)items[5], (double)(decimal)items[6]);
r.Vehicle = v;
//retrieve the customerTransaction object with given transID
command = "SELECT * FROM CustTrans WHERE transID = " + transID;
items = Query(command);
CustomerTransaction c = new CustomerTransaction();
c.Name = (string)items[1] + " " + (string)items[2];
c.Address = (string)items[3];
c.PhoneNumber = (string)items[4];
c.InsuranceNumber = (string)items[5];
CreditCard cc = new CreditCard();
cc.CardNumber = (string)items[6];
//retrieve the CreditCard object with given card number
command = "SELECT * FROM CreditCard WHERE cardNo = '" + cc.CardNumber + "'";
items = Query(command);
cc.ExpMonth = (int)items[1];
cc.ExpYear = (int)items[2];
cc.CVV = (int)items[3];
c.Card = cc;
r.CustInfo = c;
return(r);
}
public async Task Create(CustomerTransactionCreateDto dto)
{
using var tx = TransactionScopeHelper.GetInstance();
var customer = await _customerRepo.GetById(dto.CustomerId).ConfigureAwait(false) ?? throw new CustomerNotFoundException();
CustomerTransaction Transaction = new CustomerTransaction(customer, dto.Amount, dto.Type, dto.ExtraId);
await _transactionRepo.InsertAsync(Transaction).ConfigureAwait(false);
tx.Complete();
}
public async Task <IActionResult> Create([Bind("CUSTOMERID,TRANSACTIONDATE,EMPLOYEEID,AMOUNT,DESCRIPTION,REFERENCE,id")] CustomerTransaction customerTransaction)
{
if (ModelState.IsValid)
{
_context.Add(customerTransaction);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(customerTransaction));
}
public ActionResult Create([Bind(Include = "ID,TransactionTypeId,BankerId,AccountId,Amount")] CustomerTransaction customerTransaction)
{
if (ModelState.IsValid)
{
db.CustomerTransaction.Add(customerTransaction);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(customerTransaction));
}
public async Task <ActionResult> Create([FromBody] CustomerTransaction customerTransaction)
{
try
{
var result = await _customerTransactionService.CreateCustomerTransaction(customerTransaction);
return(Ok(result));
}
catch (Exception ex)
{
throw;
}
}
// GET: CustomerTransactions/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CustomerTransaction customerTransaction = db.CustomerTransaction.Find(id);
if (customerTransaction == null)
{
return(HttpNotFound());
}
return(View(customerTransaction));
}
//id = TransactionID
public async Task <ActionResult> Delete(int?id)
{
//If Transaction doesn't exist, error out
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//Query the DB CustomerTransactions Table
//Find Target transaction and send to view
CustomerTransaction targetTransaction = await db.CustomerTransactions.FindAsync(id);
return(View(targetTransaction));
}
// GET: Customer/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CustomerTransaction custTrans = Repository.getCustomerAndTransactions(id);
if (custTrans == null)
{
return(HttpNotFound());
}
return(View(custTrans));
}
public static void Main()
{
string toParse =
"[{\r\n \"kwiNumber\":\"XXXXXXXXXX\",\r\n \"transactionDetails\" : \"[\\r\\n {\\\"StoreNumber\\\":\\\"XXXXXX\\\" } \\r\\n]\"}]";
List <CustomerTransaction> records = new List <CustomerTransaction>();
JArray parsed = JArray.Parse(toParse);
foreach (var item in parsed.Children())
{
CustomerTransaction customerTransaction = JsonConvert.DeserializeObject <CustomerTransaction>(item.ToString());
customerTransaction.transactionDetails = JsonConvert.DeserializeObject <List <TransactionDetail> >(customerTransaction.transactionDetailsRaw);
records.Add(customerTransaction);
}
}
private void InitializeTransactionComponents()
{
this.db = new Models.V1.Database.CodeFirst();
this.transaction = new Transaction()
{
Db = this.db
};
this.customerTransaction = new CustomerTransaction()
{
TransactionToDb = this.transaction
};
}
public async Task <ActionResult> Delete(int id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//Find Transaction to be deleted, delete it, save DB changes
CustomerTransaction transToDelete = await db.CustomerTransactions.FindAsync(id);
db.CustomerTransactions.Remove(transToDelete);
await db.SaveChangesAsync();
return(RedirectToAction("Index", "CustomerTransaction"));
}
public HttpResponseMessage Put([FromBody] CustomerTransaction transaction)
{
var restrequest = new RestRequest("customertransaction/update", ContentMediaType.Json);
transaction.SeperatedStockItemIds = string.Join(",", transaction.StockItems.Select(p => p.StockItemId.ToString()).ToArray());
transaction.SeperatedStockItemQuantities = string.Join(",", transaction.StockItems.Select(p => p.Quantity.ToString()).ToArray());
var data = this.restClient.PutData <ApiResponse <CustomerTransaction>, CustomerTransaction>(restrequest, transaction);
if (data.Item1.Status)
{
return(Request.CreateResponse(HttpStatusCode.Created, new { Message = "transaction updated successfully" }));
}
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "We are experience some technical error. Please try again later."));
}
public void Save()
{
var payment = new CustomerTransaction
{
Id = Guid.NewGuid(),
CustomerId = Customer.Id,
DateTime = DateTimeOffset.Now,
Type = CustomerTransactionType.Adjustment,
Amount = Amount
};
CustomerService.AddTransaction(payment);
Close();
}
public async Task <IResponse> UpdateCustomerTransactionAsync(CustomerTransaction entity)
{
Logger?.LogInformation("'{0}' has been invoked", nameof(UpdateCustomerTransactionAsync));
try
{
UnitOfWork.Repository <CustomerTransaction>().Update(entity);
await UnitOfWork.SaveChangesAsync();
return(new Response());
}
catch (Exception ex)
{
return(new Response(Logger, nameof(UpdateCustomerTransactionAsync), ex));
}
}
/// <summary>
/// Creates a transaction entity associated with customer.
/// </summary>
/// <param name="walletSnapshot"></param>
/// <param name="db"></param>
/// <returns>Retruns the newly creaated transaction with the customer included in it.</returns>
private CustomerTransaction AddNewTransaction(HyperStoreServiceContext db, decimal walletSnapshot)
{
var transaction = new CustomerTransaction
{
CustomerTransactionId = Guid.NewGuid(),
CustomerOrderNo = this.Description,
IsCredit = (bool)this.IsCredit,
CustomerId = (Guid)this.CustomerId,
TransactionAmount = (decimal)this.TransactionAmount,
TransactionNo = Utility.GenerateCustomerTransactionNo(),
WalletSnapshot = walletSnapshot,
TransactionDate = DateTime.Now,
};
db.CustomerTransactions.Add(transaction);
return(transaction);
}
private void FillValues(Document document, PdfPTable fifthRow, CustomerTransaction tran)
{
PdfPCell c1, c2, c3;
PdfPTable amount;
double totalAmount = 0;
foreach (var item in tran.StockItems)
{
c1 = new PdfPCell(new Phrase(item.StockItemName, GetFont(12)));
c2 = new PdfPCell(new Phrase(item.Quantity.ToString(), GetFont(12)));
c3 = new PdfPCell(new Phrase(item.UnitPrice.ToString(), GetFont(12)));
totalAmount += item.TotalAmount;
amount = new PdfPTable(2);
var rupeesHeading = new PdfPCell(new Phrase(FormatFee(item.TotalAmount)[0], GetFont(12f)));
rupeesHeading.HorizontalAlignment = 0;
rupeesHeading.BorderWidth = 0;
var paiseHeading = new PdfPCell(new Phrase(FormatFee(item.TotalAmount)[1], GetFont(12f)));
paiseHeading.HorizontalAlignment = 2;
paiseHeading.BorderWidth = 0;
c1.HorizontalAlignment = 0;
c2.HorizontalAlignment = 1;
c3.HorizontalAlignment = 1;
amount.AddCell(rupeesHeading);
amount.AddCell(paiseHeading);
fifthRow.AddCell(c1);
fifthRow.AddCell(c2);
fifthRow.AddCell(c3);
fifthRow.AddCell(amount);
}
AddColumn("Goods Total", totalAmount.ToDecimalPlaces(2), document, fifthRow);
var vatAmount = (totalAmount * tran.Vat) / 100;
AddColumn(string.Format("Vat Amount({0}%)", tran.Vat), vatAmount.ToDecimalPlaces(2), document, fifthRow);
var discountAmount = ((totalAmount + vatAmount) * tran.Discount) / 100;
AddColumn(string.Format("Discount Amount({0}%)", tran.Discount), discountAmount.ToDecimalPlaces(2), document, fifthRow);
AddColumn("Total Amount", tran.TotalAmount.ToDecimalPlaces(2), document, fifthRow);
AddColumn("Paid Amount", tran.PaidAmount.ToDecimalPlaces(2), document, fifthRow);
AddColumn("Due Amount", tran.DueAmount.ToDecimalPlaces(2), document, fifthRow);
document.Add(fifthRow);
}
public void AddTransaction(CustomerTransaction customerTransaction)
{
using (var transaction = new TransactionScope())
using (var connection = new ConnectionScope())
{
var customer = GetCustomer(customerTransaction.CustomerId);
if (customer == null)
{
throw new Exception("Customer not found");
}
customerTransaction.Insert();
customer.Balance += customerTransaction.Amount;
customer.Update();
transaction.Complete();
}
}
public JsonResult InsertTransaction(CustomerTransaction c)
{
var result = 0;
string message = "";
if (ModelState.IsValid)
{
using (CustomerTransactionEntities ct = new CustomerTransactionEntities())
{
var SqlUpdate = @" insert into [CustomerTransaction]
([CustomerID]
,[Transaction]
,[Status]
,date) values
(@CustomerID
,@Transaction
,@Status
,getdate())
";
var CustomerIDParam = new SqlParameter("@CustomerID", c.CustomerID);
var TransactionParam = new SqlParameter("@Transaction", c.Transaction);
var StatusParam = new SqlParameter("@Status", c.Status);
result = ct.Database.ExecuteSqlCommand(SqlUpdate, CustomerIDParam, TransactionParam, StatusParam);
if (result > 0)
{
message = "Success";
}
else if (result == -1)
{
message = "Update not allowed";
}
else
{
message = "error";
}
}
}
return(new JsonResult {
Data = message, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
/// <summary>
/// Merge all values from one Entity into another one.
/// </summary>
/// <param name="source">Source Entity. Will be copied to the target.</param>
/// <param name="target">Target Entity. Will receive the values from the source.</param>
/// <returns>void.</returns>
public static void Merge(CustomerTransaction source, CustomerTransaction target)
{
// this method merges 2 Entities.
#region Merge Values
target.CustomerTransactionID = source.CustomerTransactionID;
target.CustomerID = source.CustomerID;
target.TransactionTypeID = source.TransactionTypeID;
target.InvoiceID = source.InvoiceID;
target.PaymentMethodID = source.PaymentMethodID;
target.TransactionDate = source.TransactionDate;
target.AmountExcludingTax = source.AmountExcludingTax;
target.TaxAmount = source.TaxAmount;
target.TransactionAmount = source.TransactionAmount;
target.OutstandingBalance = source.OutstandingBalance;
target.FinalizationDate = source.FinalizationDate;
target.IsFinalized = source.IsFinalized;
target.LastEditedBy = source.LastEditedBy;
target.LastEditedWhen = source.LastEditedWhen;
#endregion
}
