public IActionResult Lend(int Amount, int BorrowerId)
{
int lenId = (int)HttpContext.Session.GetInt32("LenderId");
Lender lender = _context.Lender.Where(l => l.LenderId == lenId).SingleOrDefault();
if (lender.Money < Amount)
{
TempData["error"] = "Balance is not high enough to lend that amount";
return(RedirectToAction("LenDash"));
}
Transaction fTran = _context.Transaction.Where(t => t.LenderId == lenId && t.BorrowerId == BorrowerId).SingleOrDefault();
lender.Money -= Amount;
Borrower borrower = _context.Borrower.Where(b => b.BorrowerId == BorrowerId).SingleOrDefault();
borrower.Received += Amount;
if (fTran == null)
{
Transaction transaction = new Transaction();
transaction.BorrowerId = BorrowerId;
transaction.LenderId = lenId;
transaction.CreatedAt = DateTime.Now;
transaction.UpdatedAt = DateTime.Now;
transaction.Amount = Amount;
_context.Add(transaction);
}
else
{
fTran.Amount += Amount;
fTran.UpdatedAt = DateTime.Now;
}
_context.SaveChanges();
return(RedirectToAction("LenDash"));
}
private void BuildLenderPoolFrom(string[] csvRows, bool hasHeaderRow)
{
var skipRow = hasHeaderRow;
foreach (string csvRow in csvRows)
{
//skip header row
if (skipRow)
{
skipRow = false;
continue;
}
var fields = csvRow.Split(',');
double rate = 0;
double amount = 0;
var lender = new Lender();
lender.Name = fields[0].ToString();
Double.TryParse(fields[1], out rate);
lender.Rate = rate;
Double.TryParse(fields[2], out amount);
lender.Amount = amount;
LenderPool.Add(lender);
}
}
public IActionResult GetLender(int LenderId)
{
ViewBag.UserName = HttpContext.Session.GetString("UserName");
ViewBag.UserId = HttpContext.Session.GetInt32("UserId");
System.Console.WriteLine(LenderId);
Lender thisLender = _context.lenders.SingleOrDefault(lender => lender.LenderId == LenderId);
List <Borrower> Borrowers = _context.borrowers.Include(borrower => borrower.MoneyReceived).ToList();
List <Loan> myLoans = _context.loans.Where(loan => loan.LenderId == LenderId)
.Include(loan => loan.Lender)
.Include(loan => loan.Borrower)
.ThenInclude(borrower => borrower.MoneyReceived)
.ToList();
List <Loan> allLoans = _context.loans.Include(loan => loan.Borrower).Include(loan => loan.Lender).ToList();
int moneyDonated = 0;
foreach (var loan in myLoans)
{
moneyDonated += loan.Amount;
}
ViewBag.Borrowers = Borrowers;
ViewBag.Lender = thisLender;
ViewBag.Loans = myLoans;
ViewBag.AllLoans = allLoans;
ViewBag.MoneyDonated = moneyDonated;
ViewBag.CurrentBalance = thisLender.Money - moneyDonated;
return(View());
}
public IActionResult RegLender(RegisterViewModel user)
{
if (ModelState.IsValid)
{
List <Lender> lender = _context.Lender.Where(l => l.Email == user.Email).ToList();
List <Borrower> borrower = _context.Borrower.Where(b => b.Email == user.Email).ToList();
if (lender.Count > 0 || borrower.Count > 0)
{
ViewBag.lendererror = "Email address is already registered";
return(View("Register"));
}
else
{
PasswordHasher <Lender> Hasher = new PasswordHasher <Lender>();
Lender newLender = new Lender {
FirstName = user.FirstName, LastName = user.LastName, Email = user.Email, Money = user.Money, CreatedAt = DateTime.Now, Updatedat = DateTime.Now
};
newLender.Password = Hasher.HashPassword(newLender, user.Password);
_context.Add(newLender);
_context.SaveChanges();
Lender logLender = _context.Lender.SingleOrDefault(u => u.Email == user.Email);
HttpContext.Session.SetInt32("LenderId", logLender.LenderId);
return(RedirectToAction("LenDash", "Account"));
}
}
else
{
return(View("Register"));
}
}
public async Task <int> AddLender(Lender Lender)
{
db.Lenders.Add(Lender);
int result = await db.SaveChangesAsync();
return(result);
}
/// <summary>
/// Sends an Invoice to a remote printer.
/// </summary>
/// <param name="session"></param>
/// <param name="lender"></param>
/// <returns></returns>
public static bool sendInvoice(Session session, Lender lender)
{
var s = DataRepository.GetSession(session.id);
var l = DataRepository.GetLender(lender.id);
return sendInvoice(s, l);
}
void LoanMgrSeed(AlpsContext context)
{
Lender lender = Lender.Create("张三", "350182123", "13905911234");
context.Lenders.Add(lender);
lender = Lender.Create("李四", "35018212121213", "13905911231");
context.Lenders.Add(lender);
lender = Lender.Create("王五", "3501821234121212", "13905911232");
context.Lenders.Add(lender);
// LoanVoucher loanvoucher = LoanVoucher.Create(lender.ID, 1000000, 0.006m, "456123", new DateTimeOffset(DateTime.Now.AddMonths(-4)));
// context.LoanVouchers.Add(loanvoucher);
// loanvoucher = LoanVoucher.Create(lender.ID, 2000000, 0.006m, "456124");
// context.LoanVouchers.Add(loanvoucher);
// loanvoucher.Withdraw(10000);
// context.SaveChanges();
LoanVoucher voucher = LoanVoucher.Create(lender.ID, "系统");
voucher.Deposit(DateTimeOffset.Now.AddMonths(-4), 100000, "系统测试", "系统测试");
context.LoanVouchers.Add(voucher);
voucher = LoanVoucher.Create(lender.ID, "系统");
voucher.Deposit(DateTimeOffset.Now.AddDays(-4), 200000, "系统测试", "系统测试");
context.LoanVouchers.Add(voucher);
context.SaveChanges();
}
public async Task <IActionResult> PutLender([FromRoute] int id, [FromBody] Lender lender)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != lender.Id)
{
return(BadRequest());
}
_context.Entry(lender).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LenderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public int Save(Lender lender)
{
lender.Id = lenders.Count + 1;
lenders.Add(lender);
return(lender.Id);
}
public IActionResult HandleRegisterLender(LenderRegisterViewModel model)
{
if (ModelState.IsValid)
{
PasswordHasher <Lender> Hasher = new PasswordHasher <Lender>();
Lender NewLender = new Lender
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now,
Money = model.Money
};
NewLender.Password = Hasher.HashPassword(NewLender, model.Password);
_context.Add(NewLender);
_context.SaveChanges();
Lender justEnteredLender = _context.lenders.SingleOrDefault(lender => lender.Email == model.Email);
HttpContext.Session.SetString("UserName", justEnteredLender.FirstName);
HttpContext.Session.SetInt32("UserId", justEnteredLender.LenderId);
// return RedirectToAction("Success");
return(RedirectToAction("GetLender", "Loan", new { LenderId = justEnteredLender.LenderId }));
}
System.Console.WriteLine("Not Valid!");
ViewBag.Errors = new List <string>();
return(View("RegisterLender"));
}
public IActionResult Login(string Email, string PasswordToCheck)
{
Borrower borrower = _context.Borrower.SingleOrDefault(u => u.Email == Email);
Lender lender = _context.Lender.SingleOrDefault(u => u.Email == Email);
if (borrower != null && PasswordToCheck != null)
{
var Hasher = new PasswordHasher <Borrower>();
if (0 != Hasher.VerifyHashedPassword(borrower, borrower.Password, PasswordToCheck))
{
HttpContext.Session.SetInt32("BorrowerId", borrower.BorrowerId);
return(RedirectToAction("BorrDash", "Account"));
}
}
else if (lender != null && PasswordToCheck != null)
{
var Hasher = new PasswordHasher <Lender>();
if (0 != Hasher.VerifyHashedPassword(lender, lender.Password, PasswordToCheck))
{
HttpContext.Session.SetInt32("LenderId", lender.LenderId);
return(RedirectToAction("LenDash", "Account"));
}
}
ViewBag.error = "Email address of password Incorrect";
return(View("Login"));
}
public void SatisfiedLoanRequest()
{
var lender = new Lender("Bob", 1000, 0.04);
var request = new LoanRequest(1000, 36);
request.AddLenderToLoan(lender);
Assert.True(request.IsSatisfied(), "The lender has enough funds to satisfy the Request.");
}
public void TestMinBalance()
{
Lender lender = new Lender(500);
Borrower borrower = new Borrower(50, 50);
borrower.Borrow(lender, 10, 0.04m);
borrower.PayBack(60, 0.04m);
}
private void CheckName(string[] data, Lender lender)
{
if (string.IsNullOrEmpty(data[0]))
{
throw new DataParsingException(string.Format("Name is missing in data file. Line: {0}", string.Join(",", data)));
}
lender.Name = data[0];
}
public void UnsatisifiedLoanRequest()
{
var lender = new Lender("Bob", 900, 0.04);
var request = new LoanRequest(1000, 36);
request.AddLenderToLoan(lender);
Assert.False(request.IsSatisfied(), "The lender does not have enough funds to satisfy the Request");
}
public ActionResult DeleteConfirmed(int id)
{
Lender lender = db.Lender.Find(id);
db.Lender.Remove(lender);
db.SaveChanges();
return(RedirectToAction("Index"));
}
void MonthlyRepaymentAmount()
{
var lender = new Lender("Bob", 1000, 0.07);
var request = new LoanRequest(1000, 36);
request.AddLenderToLoan(lender);
Assert.Equal(30.88, request.GetMonthlyRepaymentAmount());
}
//Sorts by Rate (asc) and Amount (desc)
private int LendersSorter(Lender a, Lender b)
{
if (a.Rate == b.Rate)
{
return(a.Available > b.Available ? -1 : 1);
}
return(a.Rate < b.Rate ? -1 : 1);
}
public async Task <int> DeleteLender(int lenderid)
{
Lender Lender = await FetchbyLenderId(lenderid);
db.Lenders.Remove(Lender);
int result = await db.SaveChangesAsync();
return(result);
}
public void Initialize()
{
if (lender == null)
{
lender = new Lender(Config.GetProperty("lender.token", ""));
Console.WriteLine("Authenticating...");
lender.Authenticate(Config.GetProperty("lender.email", ""), Config.GetProperty("lender.password", ""));
}
}
public IActionResult HandleLogin(string Email, string PasswordToCheck)
{
Lender loggedUser = _context.lenders.SingleOrDefault(lender => lender.Email == Email);
//if the person trying to log in is a lender
if (loggedUser != null && PasswordToCheck != null)
{
var Hasher = new PasswordHasher <Lender>();
if (0 != Hasher.VerifyHashedPassword(loggedUser, loggedUser.Password, PasswordToCheck))
{
HttpContext.Session.SetString("UserName", loggedUser.FirstName);
HttpContext.Session.SetInt32("UserId", loggedUser.LenderId);
return(RedirectToAction("GetLender", "Loan", new { LenderId = loggedUser.LenderId })); //change this line!
// return RedirectToAction("Success");
}
else
{
ViewBag.Errors = new List <string>();
ViewBag.Errors.Add("Invalid Login Credentials.");
return(View("Login"));
}
}
else if (loggedUser == null)
{
Borrower loggedPerson = _context.borrowers.SingleOrDefault(user => user.Email == Email);
if (loggedPerson != null && PasswordToCheck != null)
{
var PassHasher = new PasswordHasher <Borrower>();
if (0 != PassHasher.VerifyHashedPassword(loggedPerson, loggedPerson.Password, PasswordToCheck))
{
HttpContext.Session.SetString("UserName", loggedPerson.FirstName);
HttpContext.Session.SetInt32("UserId", loggedPerson.BorrowerId);
return(RedirectToAction("GetBorrower", "Loan", new { BorrowerId = loggedPerson.BorrowerId })); //change this line!
// return RedirectToAction("Success");
}
else
{
ViewBag.Errors = new List <string>();
ViewBag.Errors.Add("Invalid Login Credentials.");
return(View("Login"));
}
}
else
{
ViewBag.Errors = new List <string>();
ViewBag.Errors.Add("Invalid Login Credentials.");
return(View("Login"));
}
}
else
{
ViewBag.Errors = new List <string>();
ViewBag.Errors.Add("Invalid Login Credentials.");
return(View("Login"));
}
}
public void TestMethod1()
{
Lender lender = new Lender(500);
Borrower borrower = new Borrower(0);
//Mediator mediator = new Mediator( borrower, lender);
//mediator.Borrow(5);
borrower.Borrow(lender, 2, 0.04m);
}
public ActionResult Edit([Bind(Include = "lender_id,bankname,branchname,ifsc,b_email,contact_no,password")] Lender lender)
{
if (ModelState.IsValid)
{
db.Entry(lender).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(lender));
}
private void CheckRate(string[] data, Lender lender)
{
decimal rate;
if (!decimal.TryParse(data[1], out rate))
{
throw new DataParsingException(string.Format("Rate field can't be parsed. Line: {0}", string.Join(",", data)));
}
lender.Rate = rate;
}
private void CheckAmount(string[] data, Lender lender)
{
decimal amount;
if (!decimal.TryParse(data[2], out amount))
{
throw new DataParsingException(string.Format("Amount field can't be parsed. Line: {0}", string.Join(",", data)));
}
lender.Available = amount;
}
public async Task <int> UpdateLender(Lender Lender)
{
Lender existingLender = await FetchbyLenderId(Lender.LenderId);
db.Entry(existingLender).State = EntityState.Detached;
db.Entry(Lender).State = EntityState.Modified;
int result = await db.SaveChangesAsync();
return(result);
}
public void TotalRepaymentAmount()
{
var lender = new Lender("Bob", 1000, 0.07);
var request = new LoanRequest(1000, 36);
request.AddLenderToLoan(lender);
var total = request.GetTotalRepaymentAmount();
Assert.Equal(1111.58, request.GetTotalRepaymentAmount());
}
public ActionResult Create([Bind(Include = "lender_id,bankname,branchname,ifsc,b_email,contact_no,password")] Lender lender)
{
if (ModelState.IsValid)
{
db.Lender.Add(lender);
db.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
return(View(lender));
}
public Lender Parse(string[] data)
{
var lender = new Lender(string.Empty, 0, 0);
CheckLength(data);
CheckName(data, lender);
CheckRate(data, lender);
CheckAmount(data, lender);
return(lender);
}
public static void Log(this Lender lender, string msg, DbContext context, string indent = "")
{
if (lender != null)
{
WriteLog($"{indent} Lender '{msg}' -- state = {context.Entry(lender).State} -- id = {lender.Id}");
}
else
{
WriteLog($"{indent} Lender '{msg}' -- null");
}
}
public void MonthlyRepaymentAmountTwoLenders()
{
var lender1 = new Lender("Bob", 500, 0.07);
var lender2 = new Lender("Anne", 500, 0.07);
var request = new LoanRequest(1000, 36);
request.AddLenderToLoan(lender1);
request.AddLenderToLoan(lender2);
Assert.Equal(30.88, request.GetMonthlyRepaymentAmount());
}
public async Task <IActionResult> Post([FromBody] Lender lender)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
int id = repository.Save(lender);
return(Ok(new { Id = id }));
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(global::System.Xml.Schema.XmlSchemaSet xs) {
Lender ds = new Lender();
global::System.Xml.Schema.XmlSchemaComplexType type = new global::System.Xml.Schema.XmlSchemaComplexType();
global::System.Xml.Schema.XmlSchemaSequence sequence = new global::System.Xml.Schema.XmlSchemaSequence();
global::System.Xml.Schema.XmlSchemaAny any = new global::System.Xml.Schema.XmlSchemaAny();
any.Namespace = ds.Namespace;
sequence.Items.Add(any);
type.Particle = sequence;
global::System.Xml.Schema.XmlSchema dsSchema = ds.GetSchemaSerializable();
if (xs.Contains(dsSchema.TargetNamespace)) {
global::System.IO.MemoryStream s1 = new global::System.IO.MemoryStream();
global::System.IO.MemoryStream s2 = new global::System.IO.MemoryStream();
try {
global::System.Xml.Schema.XmlSchema schema = null;
dsSchema.Write(s1);
for (global::System.Collections.IEnumerator schemas = xs.Schemas(dsSchema.TargetNamespace).GetEnumerator(); schemas.MoveNext(); ) {
schema = ((global::System.Xml.Schema.XmlSchema)(schemas.Current));
s2.SetLength(0);
schema.Write(s2);
if ((s1.Length == s2.Length)) {
s1.Position = 0;
s2.Position = 0;
for (; ((s1.Position != s1.Length)
&& (s1.ReadByte() == s2.ReadByte())); ) {
;
}
if ((s1.Position == s1.Length)) {
return type;
}
}
}
}
finally {
if ((s1 != null)) {
s1.Close();
}
if ((s2 != null)) {
s2.Close();
}
}
}
xs.Add(dsSchema);
return type;
}
public virtual int Update(Lender dataSet) {
return this.Adapter.Update(dataSet, "Individual");
}
public virtual int Update(Lender.IndividualDataTable dataTable) {
return this.Adapter.Update(dataTable);
}
public virtual int Fill(Lender.IndividualDataTable dataTable) {
this.Adapter.SelectCommand = this.CommandCollection[0];
if ((this.ClearBeforeFill == true)) {
dataTable.Clear();
}
int returnValue = this.Adapter.Fill(dataTable);
return returnValue;
}
public virtual int Update(Lender dataSet) {
return this.Adapter.Update(dataSet, "Student");
}
public virtual int Update(Lender.StudentDataTable dataTable) {
return this.Adapter.Update(dataTable);
}
/// <summary>
/// Inserts a Lender, then returns the generated primary key
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static int InsertLender(LenderModel model)
{
var db = new BicikliDataClassesDataContext();
var lenderToInsert = new Lender();
lenderToInsert.name = model.name;
lenderToInsert.address = model.address;
lenderToInsert.description = model.description;
lenderToInsert.printer_ip = model.printer_ip;
lenderToInsert.latitude = model.latitude;
lenderToInsert.longitude = model.longitude;
if ((model.printer_password != null) && (model.printer_password != ""))
{
lenderToInsert.printer_password = model.printer_password;
}
else
{
lenderToInsert.printer_password = ((int)(new Random().NextDouble() * 899999) + 100000).ToString();
}
db.Lenders.InsertOnSubmit(lenderToInsert);
db.SubmitChanges();
return lenderToInsert.id;
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(global::System.Xml.Schema.XmlSchemaSet xs) {
global::System.Xml.Schema.XmlSchemaComplexType type = new global::System.Xml.Schema.XmlSchemaComplexType();
global::System.Xml.Schema.XmlSchemaSequence sequence = new global::System.Xml.Schema.XmlSchemaSequence();
Lender ds = new Lender();
global::System.Xml.Schema.XmlSchemaAny any1 = new global::System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = global::System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
global::System.Xml.Schema.XmlSchemaAny any2 = new global::System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = global::System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
global::System.Xml.Schema.XmlSchemaAttribute attribute1 = new global::System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
global::System.Xml.Schema.XmlSchemaAttribute attribute2 = new global::System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "StudentDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
global::System.Xml.Schema.XmlSchema dsSchema = ds.GetSchemaSerializable();
if (xs.Contains(dsSchema.TargetNamespace)) {
global::System.IO.MemoryStream s1 = new global::System.IO.MemoryStream();
global::System.IO.MemoryStream s2 = new global::System.IO.MemoryStream();
try {
global::System.Xml.Schema.XmlSchema schema = null;
dsSchema.Write(s1);
for (global::System.Collections.IEnumerator schemas = xs.Schemas(dsSchema.TargetNamespace).GetEnumerator(); schemas.MoveNext(); ) {
schema = ((global::System.Xml.Schema.XmlSchema)(schemas.Current));
s2.SetLength(0);
schema.Write(s2);
if ((s1.Length == s2.Length)) {
s1.Position = 0;
s2.Position = 0;
for (; ((s1.Position != s1.Length)
&& (s1.ReadByte() == s2.ReadByte())); ) {
;
}
if ((s1.Position == s1.Length)) {
return type;
}
}
}
}
finally {
if ((s1 != null)) {
s1.Close();
}
if ((s2 != null)) {
s2.Close();
}
}
}
xs.Add(dsSchema);
return type;
}
public virtual int Update(Lender.ApplicationDataTable dataTable) {
return this.Adapter.Update(dataTable);
}
public virtual int Update(Lender dataSet) {
return this.Adapter.Update(dataSet, "Application");
}
