public IActionResult Submit(regvalidate NewUser)
{
if (TryValidateModel(NewUser))
{
DateTime now = DateTime.Now;
User New = new User
{
first = NewUser.FirstName,
last = NewUser.LastName,
email = NewUser.Email,
password = NewUser.Password,
createdAt = DateTime.Now,
ballance = 0,
};
_context.Add(New);
_context.SaveChanges();
//add session of user
return(View("Account"));
}
else
{
Console.WriteLine("in else");
ViewBag.errors = ModelState.Values;
Console.WriteLine(ViewBag.errors);
return(View("login"));
}
}
public IActionResult Register(User model)
{
if (ModelState.IsValid)
{
User CurrentUser = new User()
{
FirstName = model.FirstName,
LastName = model.LastName,
Password = model.Password,
Email = model.Email,
ConPassword = model.ConPassword,
Balance = 400
};
//List<Dictionary<string, object>> User = _dbConnector.Query($"INSERT INTO users (first_name, last_name, email, password, age) VALUES ('{model.FirstName}', '{model.LastName}', '{model.Email}', '{model.Password}', 0)");
//userFactory.Add(CurrentUser);
_bcontext.Add(CurrentUser);
_bcontext.SaveChanges();
HttpContext.Session.SetObjectAsJson("cur_user", CurrentUser);
return(RedirectToAction("Account"));
}
else
{
string messages = string.Join("; ", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage));
Console.WriteLine(messages);
HttpContext.Session.SetObjectAsJson("reg_errors", ModelState.Values);
return(RedirectToAction("Index"));
}
//List<Dictionary<string, object>> Allq = _dbConnector.Query("SELECT * FROM quotes ORDER BY created_at Desc");
}
public async Task <IActionResult> Create([Bind("type,accountNumber,InterestRate,Balance,createdAt,CustomerId")] Checking checking)
{
if (ModelState.IsValid)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
checking.CustomerId = userId;
checking.createdAt = DateTime.Now;
checking.InterestRate = 5;
checking.type = "Checking";
_context.Add(checking);
await _context.SaveChangesAsync();
Transaction transaction = new Transaction();
transaction.accountNumber = checking.accountNumber;
transaction.accountType = "Checking";
transaction.amount = checking.Balance;
transaction.date = DateTime.Now;
transaction.type = "Account Open";
transaction.balance = checking.Balance;
_context.Add(transaction);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(CheckingView)));
}
return(View(checking));
}
public IActionResult Register(RegisterViewModel reg)
{
if (ModelState.IsValid)
{
List <User> u = _context.Users.Where(x => x.Email == reg.Email).ToList();
if (u.Count == 0)
{
// Console.WriteLine($"****{reg.Email} was not in db, need to add ");
User x = new User(reg.First, reg.Last, reg.Email, reg.Password);
_context.Add(x);
_context.SaveChanges();
HttpContext.Session.SetString("username", x.First);
HttpContext.Session.SetInt32("userid", x.Id);
Account a = new Account(0, x.Id);
_context.Add(a);
_context.SaveChanges();
string address = $"account/{x.Id}";
return(Redirect(address));
}
else
{
ModelState.AddModelError("Email", $"{reg.Email} already registered");
}
}
return(View("register"));
}
public IActionResult Register(User newUser)
{
if (ModelState.IsValid)
{
if (dbContext.users.Any(u => u.Email == newUser.Email))
{
ModelState.AddModelError("Email", "Email is already in use!");
return(View("Index"));
}
else
{
PasswordHasher <User> Hasher = new PasswordHasher <User>();
newUser.Password = Hasher.HashPassword(newUser, newUser.Password);
dbContext.Add(newUser);
dbContext.SaveChanges();
if (HttpContext.Session.GetInt32("UserId") == null)
{
HttpContext.Session.SetInt32("UserId", newUser.UserId);
}
return(RedirectToAction("Success", newUser.UserId));
}
}
else
{
System.Console.WriteLine("*******************");
System.Console.WriteLine("REGISTRATION NOT WORKING!!!!");
System.Console.WriteLine("*******************");
return(View("Index"));
}
}
public IActionResult Register(RegisterViewModel user)
{
if (ModelState.IsValid)
{
PasswordHasher <RegisterViewModel> Hasher = new PasswordHasher <RegisterViewModel>();
user.password = Hasher.HashPassword(user, user.password);
Users User = new Users()
{
first_name = user.first_name,
last_name = user.last_name,
email = user.email,
password = user.password,
created_at = DateTime.Now,
updated_at = DateTime.Now
};
// List<Users> Users = _context.users.Include(p => p.accounts).ToList();
_context.Add(User);
_context.SaveChanges();
return(RedirectToAction("Status"));
}
else
{
return(View("index"));
}
}
public IActionResult register(IndexViewModel user)
{
User regUser = user.NewRegUser;
// Check initial ModelState
if (ModelState.IsValid)
{
// If a User exists with provided email
if (dbContext.Users.Any(u => u.Email == regUser.Email))
{
ModelState.AddModelError("regUser.Email", "Email already registered!");
return(RedirectToAction("Index"));
}
else
{
PasswordHasher <User> Hasher = new PasswordHasher <User>();
regUser.Password = Hasher.HashPassword(regUser, regUser.Password);
// Add the user to database here
dbContext.Add(regUser);
dbContext.SaveChanges();
HttpContext.Session.SetString("UserEmail", regUser.Email);
return(RedirectToAction("Accounts"));
}
}
else
{
return(View("Index"));
}
}
public async Task <IActionResult> Create([Bind("period,type,accountNumber,InterestRate,Balance,createdAt,CustomerId")] Term term)
{
if (ModelState.IsValid)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
term.CustomerId = userId;
term.createdAt = DateTime.Now;
term.InterestRate = 5;
term.type = "Term";
_context.Add(term);
await _context.SaveChangesAsync();
Transaction transaction = new Transaction();
transaction.accountNumber = term.accountNumber;
transaction.accountType = "Term";
transaction.amount = term.Balance;
transaction.date = DateTime.Now;
transaction.type = "Account Open";
_context.Add(transaction);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(ViewTerms)));
}
return(View(term));
}
public async Task TestInitAsync()
{
_context.Add(user);
temp.UserId = user.Id;
_context.Add(temp);
await _context.SaveChangesAsync();
}
public IActionResult Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
User CheckUser = _context.Users.SingleOrDefault(u => u.Email == model.Email);
if (CheckUser != null)
{
TempData["EmailInUseError"] = "Email Aleady in use";
return(View("Index"));
}
else
{
PasswordHasher <User> Hasher = new PasswordHasher <User>();
User user = new User()
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
created_at = DateTime.Now
};
user.Password = Hasher.HashPassword(user, model.Password);
_context.Add(user);
_context.SaveChanges();
HttpContext.Session.SetInt32("currentUserId", user.UserId);
HttpContext.Session.SetString("currentFirstName", user.FirstName);
return(RedirectToAction("Dashboard"));
}
}
else
{
return(View("Index"));
}
}
public async Task TestInitAsync()
{
try
{
_context.Add(user);
pay.UserId = user.Id;
_context.Add(pay);
await _context.SaveChangesAsync();
}
catch { }
}
public IActionResult Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
User ExistingUser = _context.Users.SingleOrDefault(user => user.Email == model.Email);
if (ExistingUser != null)
{
ViewBag.Message = "User with this email already exists!";
return(View("Index", model));
}
PasswordHasher <User> Hasher = new PasswordHasher <User>();
User NewUser = new User
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Password = model.Password,
CreatedAt = DateTime.UtcNow,
UpdatedAt = DateTime.UtcNow
};
NewUser.Password = Hasher.HashPassword(NewUser, NewUser.Password);
_context.Add(NewUser);
_context.SaveChanges();
NewUser = _context.Users.SingleOrDefault(user => user.Email == NewUser.Email);
HttpContext.Session.SetInt32("UserId", NewUser.UserId);
return(RedirectToAction("Index", "Account", new { accountNum = HttpContext.Session.GetInt32("UserId") }));
}
else
{
return(View("Index", model));
}
}
public IActionResult CreateTransaction(double amount)
{
if (amount != 0)
{
int?id = HttpContext.Session.GetInt32("userId");
if (id == null)
{
return(RedirectToAction("LoginPage", "Users"));
}
Transaction newTransaction = new Transaction
{
UserId = (int)id,
Amount = amount,
Date = DateTime.Now
};
User user = _context.Users.Where(u => u.UserId == newTransaction.UserId).SingleOrDefault();
user.Balance += (double)newTransaction.Amount;
_context.Add(newTransaction);
_context.SaveChanges();
return(RedirectToAction("Home"));
}
else
{
return(View("Home"));
}
}
public IActionResult UserRegistration(RegisterViewModel adduser)
{
if (ModelState.IsValid)
{
User UserInDB = _context.Users.SingleOrDefault(user => user.Email == adduser.Email);
if (UserInDB != null)
{
ViewBag.Message = "This email already exists in the database.";
return(View("Index", adduser));
}
PasswordHasher <User> Hasher = new PasswordHasher <User>();
User AddUserinDB = new User
{
FirstName = adduser.FirstName,
LastName = adduser.LastName,
Email = adduser.Email,
Password = adduser.Password,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
AddUserinDB.Password = Hasher.HashPassword(AddUserinDB, AddUserinDB.Password);
_context.Add(AddUserinDB);
_context.SaveChanges();
AddUserinDB = _context.Users.SingleOrDefault(user => user.Email == AddUserinDB.Email);
HttpContext.Session.SetInt32("UserId", AddUserinDB.UserId);
return(RedirectToAction("Account", "Bank", new { accountNum = HttpContext.Session.GetInt32("UserId") }));
}
else
{
return(View("Index", adduser));
}
}
public IActionResult Register(UserValidation user)
{
List <string> Errors = new List <string> ();
if (ModelState.IsValid)
{
User Results = _context.Users.Where(u => u.Email == user.Email).SingleOrDefault();
if (Results == null)
{
_context.Add(user.ToUser());
_context.SaveChanges();
Results = _context.Users.Where(u => u.Email == user.Email).SingleOrDefault();
HttpContext.Session.SetInt32("UserId", Results.UserId);
return(RedirectToAction("Main", "Bank"));
}
else
{
Errors.Add("User already exists, try a different E-Mail");
}
}
else
{
Dictionary <string, string> Error = new Dictionary <string, string> ();
foreach (string key in ViewData.ModelState.Keys)
{
foreach (ModelError error in ViewData.ModelState[key].Errors)
{
Errors.Add(error.ErrorMessage);
}
}
}
HttpContext.Session.SetObjectAsJson("Errors", Errors);
return(RedirectToAction("Register"));
}
private void btnLogin_Click(object sender, EventArgs e)
{
try
{
using (var contexto = new BankContext())
{
var NovoTitular = new TitularConta()
{
Nome = textBoxNomeCliente.Text,
Morada = textBoxMorada.Text,
Cidade = textBoxCidade.Text,
Email = textBoxEmail.Text,
Senha = int.Parse(textBoxSenha.Text),
};
contexto.Add(NovoTitular);
contexto.SaveChanges();
}
MessageBox.Show("Registo Efetuado com sucesso. Obrigado");
PaginaPrincipal nova = new PaginaPrincipal();
nova.reiniciar();
Close();
}catch (Exception)
{
MessageBox.Show("Erro, preencha todos os dados");
}
}
public async Task <IActionResult> Create([Bind("type,accountNumber,InterestRate,Balance,createdAt")] Checking checking)
{
if (ModelState.IsValid)
{
Transaction transaction = new Transaction();
transaction.Customers = checking.Customers;
transaction.accountNumber = checking.accountNumber;
transaction.accountType = "checking";
transaction.amount = checking.Balance;
transaction.date = DateTime.Now;
transaction.type = "Opening";
_context.Update(transaction);
await _context.SaveChangesAsync();
checking.accountNumber = ListEnums.accntNumberChk;
_context.Add(checking);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(checking));
}
public IActionResult Register(UserViewModel RegUser)
{
if (!ModelState.IsValid)
{
return(View("Index"));
}
else
{
User UserCheck = _context.Users.SingleOrDefault(user => user.Email == RegUser.RegisterUser.Email);
if (UserCheck != null)
{
ViewBag.EmailExists = "That user already exists!";
return(View("Index"));
}
else
{
PasswordHasher <Register> hasher = new PasswordHasher <Register>();
string HashedPW = hasher.HashPassword(RegUser.RegisterUser, RegUser.RegisterUser.Password);
User NewUser = new User
{
FirstName = RegUser.RegisterUser.FirstName,
LastName = RegUser.RegisterUser.LastName,
Email = RegUser.RegisterUser.Email,
Password = HashedPW,
};
_context.Add(NewUser);
_context.SaveChanges();
User LoggedIn = _context.Users.SingleOrDefault(user => user.Email == RegUser.RegisterUser.Email);
HttpContext.Session.SetInt32("UserId", LoggedIn.UserId);
HttpContext.Session.SetString("UserName", LoggedIn.FirstName);
return(RedirectToAction("UserHome"));
}
}
}
public async Task <Transaction> Add(Transaction transaction)
{
_context.Add(transaction); //Change Tracker : only change the state
await _context.SaveChangesAsync();
return(transaction);
}
public async Task <IActionResult> AddTemplate(Template template)
{
if (ModelState.IsValid)
{
User user = null;
string userId = HttpContext.Session.GetString("UserId");
SessionHandler.GetUser(userId, out user);
if (!_context.IsTemplateNameUnique(template.Name, user.Id))
{
ViewBag.ErrName = "Template name must be unique.";
return(View(template));
}
template.UserId = user.Id;
try
{
_context.Add(template);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(TemplateList)));
}
catch
{
return(Redirect("/Home/Error"));
}
}
return(View(template));
}
public IActionResult AddTransaction(Transaction newtransaction)
{
if (ModelState.IsValid)
{
int? id = HttpContext.Session.GetInt32("ActiveId");
int ActiveId = (int)id;
User user = _context.users.SingleOrDefault(u => u.UserId == ActiveId);
if (newtransaction.Amount < 0 && Math.Abs(newtransaction.Amount) > user.Balance)
{
TempData["err"] = "Not enough money on your Account!";
}
else
{
Transaction newtrans = new Transaction()
{
Description = newtransaction.Description,
Amount = newtransaction.Amount,
Date = DateTime.Now,
UserId = ActiveId,
};
user.Balance += newtransaction.Amount;
_context.Add(newtrans);
_context.SaveChanges();
TempData["err"] = "Transaction complete!";
}
}
return(RedirectToAction("Account"));
}
public async Task <IActionResult> Create([Bind("type,accountNumber,InterestRate,Balance,createdAt,CustomerId")] Business business)
{
if (ModelState.IsValid)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
business.CustomerId = userId;
business.createdAt = DateTime.Now;
business.InterestRate = 5;
business.type = "Business";
_context.Add(business);
await _context.SaveChangesAsync();
Transaction transaction = new Transaction();
transaction.accountNumber = business.accountNumber;
transaction.accountType = "Business";
transaction.amount = business.Balance;
transaction.date = DateTime.Now;
transaction.type = "Account Opening";
transaction.balance = business.Balance;
_context.Update(transaction);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(BusinessView)));
}
return(View(business));
}
public IActionResult RegisterUser(RegisterUser newUser)
{
if (_context.Users.Where(user => user.Email == newUser.Email).SingleOrDefault() != null)
{
ModelState.AddModelError("Email", "Email already in use");
}
PasswordHasher <RegisterUser> hasher = new PasswordHasher <RegisterUser>();
if (ModelState.IsValid)
{
User theUser = new User
{
FirstName = newUser.FirstName,
LastName = newUser.LastName,
Email = newUser.Email,
Password = hasher.HashPassword(newUser, newUser.Password),
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now,
};
User loggedUser = _context.Add(theUser).Entity;
_context.SaveChanges();
HttpContext.Session.SetInt32("id", loggedUser.UserId);
return(Redirect($"/Dashboard/{loggedUser.UserId}"));
}
;
return(View("Index"));
}
public IActionResult Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
User NewUser = new User
{
FirstName = model.FirstName,
LastName = model.LastName,
EmailId = model.EmailId,
Password = model.Password,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
// Handle success
System.Console.WriteLine("Came here");
_context.Add(NewUser);
_context.SaveChanges();
System.Console.WriteLine("Done adding to DB");
User EnteredPerson = _context.user.SingleOrDefault(user => user.EmailId == model.EmailId);
HttpContext.Session.SetString("FirstName", EnteredPerson.FirstName);
HttpContext.Session.SetInt32("UserId", EnteredPerson.UserId);
return(RedirectToAction("show", EnteredPerson.UserId));
}
else
{
ViewBag.errors = ModelState.Values;
ViewBag.Errors = new List <string>();
return(View("Index"));
}
}
public IActionResult render(int Amount)
{
System.Console.WriteLine("We're in the render route!");
string mytype = "Deposit";
bankaccounts.Models.Action NewAction = new bankaccounts.Models.Action {
amount = Amount,
created_at = DateTime.Now,
updated_at = DateTime.Now,
userid = (int)HttpContext.Session.GetInt32("CurrUserId")
};
User ThisUser = _context.Users.SingleOrDefault(u => u.userid ==
HttpContext.Session.GetInt32("CurrUserId"));
if (Amount < 0)
{
mytype = "Withdrawal";
if ((-1 * Amount) > ThisUser.money)
{
HttpContext.Session.SetString("NoMoneyError", "Not enough money. :(");
return(RedirectToAction("Account", "Login"));
}
}
NewAction.type = mytype;
ThisUser.money += Amount;
_context.Add(NewAction);
_context.SaveChanges();
return(RedirectToAction("Account", "Login"));
}
public IActionResult createUser(Register regUser)
{
if (ModelState.IsValid)
{
User exists = _context.Users.SingleOrDefault(user => user.Email == regUser.Email);
if (exists != null)
{
ModelState.AddModelError("Email", "An account with this email already exists!");
return(View("Index"));
}
else
{
PasswordHasher <Register> Hasher = new PasswordHasher <Register>();
string hashed = Hasher.HashPassword(regUser, regUser.Password);
User newUser = new User
{
FirstName = regUser.FirstName,
LastName = regUser.LastName,
Email = regUser.Email,
Password = hashed,
Balance = 0.00
};
_context.Add(newUser);
_context.SaveChanges();
User user = _context.Users.Where(u => u.Email == regUser.Email).SingleOrDefault();
HttpContext.Session.SetInt32("userId", user.UserId);
HttpContext.Session.SetString("userName", user.FirstName);
return(RedirectToAction("Home", "Accounts"));
}
}
else
{
return(View("Index"));
}
}
public async Task <Customer> Add(Customer customer)
{
_context.Add(customer); //Change Tracker : only change the state
await _context.SaveChangesAsync();
return(customer);
}
public IActionResult RunTransaction(Transaction NewTransaction)
{
System.Console.WriteLine("adding newTransction");
NewTransaction.CreatedAt = DateTime.Now;
var loggedUserId = HttpContext.Session.GetInt32("UserId");
var update_success = Update(NewTransaction.Amount);
if (update_success)
{
NewTransaction.UserId = loggedUserId.Value;
_context.Add(NewTransaction);
_context.SaveChanges();
}
else
{
System.Console.WriteLine(" ################In Else");
ViewBag.status = new List <string>()
{
"Invalid Amount"
};
}
return(RedirectToAction("show", "Home"));
}
public IActionResult Process(RegisterViewModel model)
{
ViewBag.Errors = new List <string>();
System.Console.WriteLine("In register route");
if (ModelState.IsValid)
{
User NewUser = new User {
firstname = model.firstname,
lastname = model.lastname,
email = model.email,
password = model.password,
created_at = DateTime.Now,
updated_at = DateTime.Now
};
_context.Add(NewUser);
_context.SaveChanges();
HttpContext.Session.SetInt32("CurrUserId", NewUser.userid);
return(RedirectToAction("Account"));
}
else
{
System.Console.WriteLine("Something failed...");
ViewBag.Errors = ModelState.Values;
return(View("register"));
}
}
public Task <int> Add(Account entity)
{
entity.Password = CommonFunction.CreatePasswordHash(entity.Password, Conts.PASSWORD_SALT);
entity.CreatedDate = DateTime.Now;
_context.Add(entity);
_context.Entry(entity).State = EntityState.Added;
return(_context.SaveChangesAsync());
}
