public ActionResult Create([Bind(Include = "ClientAccountId, Amount,BalanceType,Description,Timestamp")] ClientBalanceHistory clientBalanceHistory)
{
if (ModelState.IsValid)
{
if (clientBalanceHistory.BalanceType == BalanceChangeType.Cashout)
{
if (clientBalanceHistory.Amount > 0)
{
clientBalanceHistory.Amount = clientBalanceHistory.Amount * -1;
}
}
db.ClientBalanceHistories.Add(clientBalanceHistory);
var client = db.ClientAccounts.Find(clientBalanceHistory.ClientAccountId);
client.Balance += clientBalanceHistory.Amount;
db.Entry(client).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", new { accountId = clientBalanceHistory.ClientAccountId }));
}
return(View(clientBalanceHistory));
}
public ActionResult Create([Bind(Include = "ClientAccountId,StartAmount,StartDate,FreeDays,InterestRate, Notes")] Loan loan)
{
if (ModelState.IsValid)
{
DateTime time = DateTime.Now;
loan.Timestamp = time;
loan.EndDate = null;
loan.CurrentAmount = loan.StartAmount;
db.Loans.Add(loan);
var client = db.ClientAccounts.Find(loan.ClientAccountId);
if (client.Loan + loan.StartAmount > client.LoanLimit)
{
throw new InvalidOperationException("超出贷款上限");
}
client.Loan += loan.StartAmount;
db.Entry(client).State = EntityState.Modified;
db.SaveChanges();
client.Balance += loan.StartAmount;
var clientBalanceHistory = new ClientBalanceHistory()
{
Amount = loan.StartAmount,
BalanceType = BalanceChangeType.Loan,
ClientAccountId = client.ClientAccountId,
Description = string.Format("Loan for LoanId: {0}.", loan.LoanId),
Timestamp = time
};
db.ClientBalanceHistories.Add(clientBalanceHistory);
var loanHistory = new LoanHistory()
{
Amount = loan.StartAmount,
DealDate = loan.StartDate,
ChangeType = LoanChangeType.Loan,
Interest = 0,
LoanId = loan.LoanId,
Notes = loan.Notes,
Timestamp = time
};
db.LoanHistories.Add(loanHistory);
db.SaveChanges();
return(RedirectToAction("Index", new { accountId = loan.ClientAccountId }));
}
return(View(loan));
}
public ActionResult Edit([Bind(Include = "ClientBalanceHistoryId,Amount,BalanceType,Description,Timestamp")] ClientBalanceHistory clientBalanceHistory)
{
if (ModelState.IsValid)
{
db.Entry(clientBalanceHistory).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(clientBalanceHistory));
}
public ActionResult PayConfirmed([Bind(Include = "ClientSubscriptionId, Notes, Timestamp")] ClientSubscription subscription)
{
if (ModelState.IsValid)
{
DateTime time = subscription.Timestamp;
ClientSubscription clientSubscription = db.ClientSubscriptions.Find(subscription.ClientSubscriptionId);
long clientAccountId = clientSubscription.ClientAccountId;
ClientAccount client = db.ClientAccounts.Find(clientAccountId);
if (client.Balance >= clientSubscription.UnitPrice * clientSubscription.StartQuantity)
{
clientSubscription.State = ClientSubscriptionState.Paid;
db.Entry(clientSubscription).State = EntityState.Modified;
client.Balance -= clientSubscription.UnitPrice * clientSubscription.StartQuantity;
clientSubscription.Timestamp = time;
db.Entry(client).State = EntityState.Modified;
var clientSubscriptionHistory = new ClientSubscriptionHistory()
{
UnitPrice = clientSubscription.UnitPrice,
State = ClientSubscriptionState.Paid,
Quantity = clientSubscription.StartQuantity,
VesselName = subscription.VesselName,
Notes = clientSubscription.Notes,
ClientSubscriptionId = clientSubscription.ClientSubscriptionId,
Timestamp = time
};
db.ClientSubscriptionHistories.Add(clientSubscriptionHistory);
var clientBalanceHistory = new ClientBalanceHistory()
{
Amount = clientSubscription.UnitPrice * clientSubscription.StartQuantity * -1,
BalanceType = BalanceChangeType.Pay,
ClientAccountId = clientAccountId,
Description = string.Format("Pay for Subscription: {0}.", subscription.ClientSubscriptionId),
Timestamp = time
};
db.ClientBalanceHistories.Add(clientBalanceHistory);
db.SaveChanges();
return(RedirectToAction("Index", new { accountId = clientAccountId }));
}
return(View("The balance is not enough to pay the subscription."));
}
return(View("The state is not valid."));
}
// GET: ClientBalanceHistories/Edit/5
public ActionResult Edit(long?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ClientBalanceHistory clientBalanceHistory = db.ClientBalanceHistories.Find(id);
if (clientBalanceHistory == null)
{
return(HttpNotFound());
}
return(View(clientBalanceHistory));
}
// GET: ClientBalanceHistories/Create
public ActionResult Create(long?accountId)
{
if (accountId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var balanceHistory = new ClientBalanceHistory()
{
ClientAccountId = accountId.Value
};
return(View(balanceHistory));
}
public ActionResult DeleteConfirmed(long id)
{
ClientBalanceHistory clientBalanceHistory = db.ClientBalanceHistories.Find(id);
var clientId = clientBalanceHistory.ClientAccountId;
db.ClientBalanceHistories.Remove(clientBalanceHistory);
var client = db.ClientAccounts.Find(clientId);
client.Balance -= clientBalanceHistory.Amount;
db.Entry(client).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", new { accountId = clientId }));
}
public ActionResult RepayConfirmed([Bind(Include = "LoanId,RepayDate, RepayAmount, Notes")] LoanRepayViewModel loanRepayViewModel)
{
DateTime time = DateTime.Now;
if (ModelState.IsValid)
{
var loan = db.Loans.Find(loanRepayViewModel.LoanId);
if (loan == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
double totalRepayAmount = GetRepayAmountWithInterest(
loanRepayViewModel.RepayAmount,
loan.InterestRate,
loan.StartDate,
loanRepayViewModel.RepayDate,
loan.FreeDays);
var client = db.ClientAccounts.Find(loan.ClientAccountId);
if (client == null)
{
return(HttpNotFound());
}
if (client.Balance < totalRepayAmount)
{
return(View(string.Format("The balance is not enough to pay the loan with interest {0}.", totalRepayAmount)));
}
client.Loan -= loanRepayViewModel.RepayAmount;
client.Balance -= totalRepayAmount;
db.Entry(client).State = EntityState.Modified;
var loanHistory = new LoanHistory()
{
Amount = loanRepayViewModel.RepayAmount * -1,
DealDate = loanRepayViewModel.RepayDate,
Interest = totalRepayAmount - loanRepayViewModel.RepayAmount,
ChangeType = LoanChangeType.Repay,
LoanId = loan.LoanId,
Notes = loan.Notes,
Timestamp = time
};
db.LoanHistories.Add(loanHistory);
loan.CurrentAmount -= loanRepayViewModel.RepayAmount;
loan.Timestamp = time;
if (loan.CurrentAmount == 0)
{
loan.EndDate = loanRepayViewModel.RepayDate;
}
db.Entry(loan).State = EntityState.Modified;
var clientBalanceHistory = new ClientBalanceHistory()
{
Amount = totalRepayAmount * -1,
BalanceType = BalanceChangeType.LoanRepay,
ClientAccountId = client.ClientAccountId,
Description = string.Format("Repay for Loan: {0}.", loan.LoanId),
Timestamp = time
};
db.ClientBalanceHistories.Add(clientBalanceHistory);
try
{
db.SaveChanges();
}
catch (DbEntityValidationException e)
{
string errorMessage = "";
foreach (var result in e.EntityValidationErrors)
{
foreach (var error in result.ValidationErrors)
{
errorMessage += error.ErrorMessage;
}
}
throw new Exception(errorMessage);
}
return(RedirectToAction("Index", new { accountId = client.ClientAccountId }));
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
