public ActionResult Defined([Bind(Include = "ID,TransactionDate,FromID,ToID,Amount,Defined,Title")] Transaction transaction)
{
if (ModelState.IsValid)
{
transaction.Defined = false;
transaction.TransactionDate = DateTime.Now;
BankAccount fr = db.BankAccounts.Single(e => e.ID == transaction.FromID);
BankAccount target = db.BankAccounts.Single(e => e.ID == transaction.ToID);
if (fr.Balance < transaction.Amount)
{
return(RedirectToAction("Index"));
}
target.Balance += transaction.Amount;
fr.Balance -= transaction.Amount;
db.Transactions.Add(transaction);
db.SaveChanges();
Profile current = db.Profiles.Single(e => e.UserName == User.Identity.Name);
if (current.EnableMail)
{
SendMail(target.Profile.UserName, "You received transfer", "You have new transaction. Visit us to check. Virtual bank");
}
db.Entry(transaction).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.FromID = new SelectList(db.BankAccounts, "ID", "Number", transaction.FromID);
ViewBag.ToID = new SelectList(db.BankAccounts, "ID", "Number", transaction.ToID);
return(View(transaction));
}
// GET: Worker
public ActionResult Index(int?id, int?organizationID)
{
var viewModel = new WorkerIndexData();
viewModel.Workers = db.Workers
.Include(i => i.Office)
.Include(i => i.Organizations.Select(c => c.Department))
.OrderBy(i => i.LastName);
if (id != null)
{
ViewBag.WorkerID = id.Value;
viewModel.Organizations = viewModel.Workers.Where(
i => i.ID == id.Value).Single().Organizations;
}
if (organizationID != null)
{
ViewBag.CourseID = organizationID.Value;
// Lazy loading
//viewModel.Enrollments = viewModel.Courses.Where(
// x => x.CourseID == courseID).Single().Enrollments;
// Explicit loading
var selectedCourse = viewModel.Organizations.Where(x => x.OrganizationID == organizationID).Single();
db.Entry(selectedCourse).Collection(x => x.Enrollments).Load();
foreach (Enrollment enrollment in selectedCourse.Enrollments)
{
db.Entry(enrollment).Reference(x => x.Client).Load();
}
viewModel.Enrollments = selectedCourse.Enrollments;
}
return(View(viewModel));
}
public virtual void Delete(TEntity entityToDelete)
{
if (Context.Entry(entityToDelete).State == EntityState.Detached)
{
dbSet.Attach(entityToDelete);
}
dbSet.Remove(entityToDelete);
}
public ActionResult Edit([Bind(Include = "Id,Name,LastName,Email,Pesel,BirthDate,MothersName")] Profile profile)
{
if (ModelState.IsValid)
{
db.Entry(profile).State = EntityState.Modified;
db.SaveChanges();
}
return(RedirectToAction("Index", new { id = profile.Id }));
}
public ActionResult My([Bind(Include = "ID,UserName,Name,Surname,EnableMail")] Profile profile)
{
if (ModelState.IsValid)
{
db.Entry(profile).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("My"));
}
return(View(profile));
}
public IHttpActionResult PutPas(string id, Pas pas)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != pas.PasID)
{
return(BadRequest());
}
db.Entry(pas).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!PasExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult Edit([Bind(Include = "ID,CreditAmount,State")] CreditApplication creditApplication)
{
if (ModelState.IsValid)
{
var creditApplicationEdit = db.CreditApplications.Single(c => c.ID == creditApplication.ID);
creditApplicationEdit.State = creditApplication.State;
db.Entry(creditApplicationEdit).State = EntityState.Modified;
if (creditApplicationEdit.State == true)
{
var profile = db.Profiles
.Single(p => p.CreditApplications
.Any(c => c.ID == creditApplicationEdit.ID));
var toBankAccount = profile.BankAccounts
.First(b => b.BankAccountType.Type == "PAY_ACC_FOR_YOUNG" || b.BankAccountType.Type == "PAY_ACC_FOR_ADULT");
var value = creditApplicationEdit.CreditAmount;
toBankAccount.Balance += value;
toBankAccount.AvailableFounds += value;
Credit credit = new Credit
{
CreditAmount = creditApplicationEdit.CreditAmount,
TotalRepayment = creditApplicationEdit.TotalRepayment,
CurrentRepayment = 0m,
MonthRepayment = creditApplicationEdit.MonthRepayment,
NumberOfMonths = creditApplicationEdit.NumberOfMonths,
NumberOfMonthsToEnd = creditApplicationEdit.NumberOfMonths,
StartDate = DateTime.Now,
IsPaidOff = false,
Type = creditApplicationEdit.Type
};
db.Credits.Add(credit);
profile.Credits.Add(credit);
Transaction transaction = new Transaction
{
ValueTo = value,
ValueFrom = value,
BalanceAfterTransactionUserTo = toBankAccount.Balance,
CurrencyTo = toBankAccount.Currency,
ToBankAccountNumber = toBankAccount.BankAccountNumber,
FromBankAccountNumber = toBankAccount.BankAccountNumber,
TransactionTypeID = db.TransactionTypes.Single(t => t.Type == "CREDIT_TRANSFER").ID,
Description = $"Kredyt {credit.ID}",
ReceiverName = profile.FullName,
Date = DateTime.Now
};
db.Transactions.Add(transaction);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(creditApplication));
}
//PUT: api/Bank/1
public async Task <ActionResult <Bank> > PutBank(int id, Bank bank)
{
if (bank.BankID != id)
{
return(BadRequest());
}
_context.Entry(bank).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!_context.Banks.Any(e => e.BankID == id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IHttpActionResult PutKlant(int id, Klant klant)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != klant.KlantID)
{
return(BadRequest());
}
db.Entry(klant).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!KlantExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public IHttpActionResult PutTransactie(int id, Transactie transactie)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != transactie.TransactieID)
{
return(BadRequest());
}
db.Entry(transactie).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!TransactieExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> PutCustomer(long id, Customer customer)
{
if (id != customer.Id)
{
return(BadRequest());
}
_context.Entry(customer).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCustomers([FromRoute] long id, [FromBody] Customers customers)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != customers.id)
{
return(BadRequest());
}
_context.Entry(customers).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomersExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IHttpActionResult PutRekening(int id, Rekening rekening)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != rekening.RekeningNr)
{
return(BadRequest());
}
db.Entry(rekening).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!RekeningExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult Edit([Bind(Include = "Id,Balance,Filial_owner")] Terminal terminal)
{
if (ModelState.IsValid)
{
var b = terminal.Balance;
var f = terminal.Filial_owner;
// Подхватываем Вопрос из БД, ибо иначе EF не подтягивает нам связанные сущности,
// из-за чего и не обновляется список тем.
// terminal = db.Clients.Find(client.Id);
// Очищаем старый список, чтобы не было ошибок при сохранении
// (иначе заорет на попытку добавления повторяющегося ключа).
// client.Cards.Clear();
terminal.Balance = b;
terminal.Filial_owner = f;
// var selectedTopics = new List<Card>();
// if (cards != null)
// {
// foreach (var top in cards)
// {
// selectedTopics.Add(db.Cards.SingleOrDefault(to => to.Id == top));
// }
// }
// client.Cards = selectedTopics;
db.Entry(terminal).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(terminal));
}
public async Task <T> Update <T>(T entity) where T : BaseEntity
{
_context.Entry(entity).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(entity);
}
public async Task <ActionResult> PutBankAccount(int id, BankAccount bankAccount)
{
if (id != bankAccount.BankAccountID)
{
return(BadRequest());
}
_context.Entry(bankAccount).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BankAccountExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Edit(Account account)
{
if (db.Accounts.Contains(account))
{
db.Entry(account).State = EntityState.Modified;
db.SaveChanges();
}
}
public void Edit(Bank bank)
{
if (db.Banks.Contains(bank))
{
db.Entry(bank).State = EntityState.Modified;
db.SaveChanges();
}
}
public IActionResult EditCustomer(CustomerViewModel cust)
{
if (ModelState.IsValid)
{
var old = _context.Customers.SingleOrDefault(c => c.CustomerId == cust.CustomerID);
_context.Entry(old).CurrentValues.SetValues(cust);
_context.SaveChanges();
ModelState.Clear();
TempData["Message"] = "User updated";
return(View(cust));
}
TempData["Message"] = "User not updated. Please check values";
return(View(cust));
}
public ActionResult EditStudent(Student student)
{
try
{
if (ModelState.IsValid)
{
db.Entry(student).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("ListStudents"));
}
}
catch (DataException)
{
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return(View(student));
}
public void Delete(Transaction entity)
{
using (BankContext context = new BankContext(_options))
{
var deletedEntity = context.Entry(entity);
deletedEntity.State = EntityState.Deleted;
context.SaveChanges();
}
}
public void Add(Transaction entity)
{
using (BankContext context = new BankContext(_options))
{
var addedEntity = context.Entry(entity);
addedEntity.State = EntityState.Added;
context.SaveChanges();
}
}
public async Task <IActionResult> PutSavingItem(int Id, Saving item)
{
item.Id = Id;
_context.Entry(item).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(NoContent());
}
public void Update(Transaction entity)
{
using (BankContext context = new BankContext(_options))
{
var updatedEntity = context.Entry(entity);
updatedEntity.State = EntityState.Modified;
context.SaveChanges();
}
}
public async Task <IActionResult> PostUser_Client_Card_Info(string appid, [FromBody] User_Client_Card_Info user_Client_Card_Info, [FromServices]
BankContext BankDb)
{
try
{
//Authentication of API
if (appid == null)
{
return(BadRequest());
}
var user = _context.Users.Where(e => e.AppId.ToString().CompareTo(appid) == 1).Select(e => e);
if (user == null)
{
return(BadRequest("You are not authorised to use the API, Please register or Contact Administrator"));
}
// Verify Model
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//Check if user has valid card details
if (_context.User_Clients_Card_Info.Where(e => e.CardNumber == user_Client_Card_Info.CardNumber) == null)
{
return(BadRequest("Card Number is not valid"));
}
var bank_User_Client_Card_Info = BankDb.Bank_User_Client_Card_Info.Where(e => e.CardNumber == user_Client_Card_Info.CardNumber).Select(e => e).FirstOrDefault();
if (bank_User_Client_Card_Info == null)
{
return(BadRequest("Card Number is not valid"));
}
decimal availableAmount = 0;
var account = BankDb.Bank_User_Client_Account.Where(e => e.AccountNumber == bank_User_Client_Card_Info.AccountNumber).FirstOrDefault();
if (account == null)
{
return(BadRequest("Account Number is not valid"));
}
availableAmount = account.AvailableAmount - user_Client_Card_Info.TransactionAmount;
account.AvailableAmount = availableAmount;
BankDb.Entry(account).State = EntityState.Modified;
try
{
await BankDb.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(NotFound());
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(CreatedAtAction("GetUser_Client_Card_Info", new { id = user_Client_Card_Info.CardNumber }, user_Client_Card_Info));
}
public ActionResult Edit([Bind(Include = "ID,Date,Amount,TransactionType")] Transaction transaction)
{
if (ModelState.IsValid)
{
db.Entry(transaction).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(transaction));
}
public ActionResult Edit([Bind(Include = "Id,ProfileId,BankAccountId,Cash,NumberOfMonths,Picture")] CreditProposal creditProposal)
{
if (ModelState.IsValid)
{
db.Entry(creditProposal).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(creditProposal));
}
public ActionResult Edit([Bind(Include = "RekeningNr,Balans,RekeningType,KlantNr,Hash")] Rekening rekening)
{
if (ModelState.IsValid)
{
db.Entry(rekening).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(rekening));
}
public ActionResult Edit([Bind(Include = "ID,Name,Code,EffectiveDate,Bid,Ask")] Currency currency)
{
if (ModelState.IsValid)
{
db.Entry(currency).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(currency));
}
public ActionResult Edit(Loan loan)
{
if (ModelState.IsValid)
{
db.Entry(loan).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(loan));
}
