public Status Login(string fnUsername, string password)
{
//check if username exists
var acc = _accContext.Accounts.Find(fnUsername);
if (acc == null)
{
return(new Status(false, "Username does not exist"));
}
//check if password is correct
HashingService hs = new HashingService();
byte[] hash = hs.GenerateHashWithSalt(acc.Salt, password);
if (hash != acc.PasswordHash)
{
return(new Status(false, "Password was incorrect"));
}
//set Logged in status
acc.LoggedIn = true;
_accContext.Accounts.Attach(acc);
_accContext.Entry(acc).Property(x => x.LoggedIn).IsModified = true;
_accContext.SaveChanges();
return(new Status(true, "success"));
}
public virtual void Delete(TEntity entity)
{
if (context.Entry(entity).State == EntityState.Detached)
{
dbSet.Attach(entity);
dbSet.Remove(entity);
}
}
public virtual void Delete(TEntity user)
{
if (Context.Entry(user).State == EntityState.Detached)
{
dbset.Attach(user);
}
dbset.Remove(user);
}
/// <summary>
/// Removes account from database
/// </summary>
/// <param name="account">Account DTO object to remove</param>
public void RemoveAccount(BankAccountDTO account)
{
var foundAccount = context.Accounts.Find(account.Id);
if (foundAccount == null)
{
throw new ArgumentException("The database doesn't contain given account");
}
context.Accounts.Remove(foundAccount);
context.Entry(foundAccount).State = EntityState.Deleted;
context.SaveChanges();
}
public ActionResult Details([Bind(Include = "Id")] Profile profile)
{
Profile prof = db.Profiles.Find(profile.Id);
HttpPostedFileBase file = Request.Files["photoFile"];
if (file != null && file.ContentLength > 0)
{
prof.Photo = file.FileName;
file.SaveAs(HttpContext.Server.MapPath("~/Photos/" + file.FileName));
}
db.Entry(prof).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Details"));
}
public async Task <IActionResult> PutUser(int id, User user)
{
if (id != user.Userid)
{
return(BadRequest());
}
_context.Entry(user).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult Edit(int?id, string[] selectedRoles)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var userToUpdate = db.SysUsers.Include(t => t.UserRoles).Where(u => u.ID == id).Single();
if (TryUpdateModel(userToUpdate, "", new string[] { "LoginName", "PassWord", "Email", "CreateDate", "SysDepartmentId" }))
{
try
{
UpdateUserRoles(selectedRoles, userToUpdate);
db.Entry(userToUpdate).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
string error = ex.Message;
}
finally { }
}
//如果失败重新绑定视图
ViewBag.SysDepartmentId = new SelectList(db.SysDepartments, "Id", "DepartmentName", userToUpdate.SysDepartmentId);
//将用户下的角色信息显示
PopulateAssignedRoleData(userToUpdate);
return(View(userToUpdate));
}
public async Task <object> Delete(string account_name)
{
WarcraftAcct account_entry = await GetAccountID(account_name);
if (account_entry != null)
{
//if account exists delete
//if account exists and deleted then undelete
account_entry.active = !account_entry.active;
_db.Entry(account_entry).State = EntityState.Modified;
await _db.SaveChangesAsync();
return(new { account = FirstToUpper(account_name), active = account_entry.active });
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Request Error: Account Invalid"));
}
public async Task <IActionResult> PutAccount([FromRoute] string id, [FromBody] Account account)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != account.Id)
{
return(BadRequest());
}
_context.Entry(account).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AccountExists(id))
{
return(NotFound(0));
}
else
{
throw;
}
}
return(NoContent());
}
public async void Test_Repository_InsertAsync()
{
using (var ctx = new AccountContext(options))
{
var accounts = new Repository <AccountModel>(ctx);
await accounts.InsertAsync(_account);
Assert.Equal(EntityState.Added, ctx.Entry(_account).State);
}
using (var ctx = new AccountContext(options))
{
var profiles = new Repository <ProfileModel>(ctx);
await profiles.InsertAsync(_profile);
Assert.Equal(EntityState.Added, ctx.Entry(_profile).State);
}
using (var ctx = new AccountContext(options))
{
var addresses = new Repository <AddressModel>(ctx);
await addresses.InsertAsync(_address);
Assert.Equal(EntityState.Added, ctx.Entry(_address).State);
}
}
public async void Test_Repository_DeleteAsync()
{
using (var ctx = new AccountContext(options))
{
var profiles = new Repository <ProfileModel>(ctx);
var profile = await ctx.Profiles.FirstAsync();
await profiles.DeleteAsync(profile.EntityId);
Assert.Equal(EntityState.Deleted, ctx.Entry(profile).State);
}
using (var ctx = new AccountContext(options))
{
var addresses = new Repository <AddressModel>(ctx);
var address = await ctx.Addresses.FirstAsync();
await addresses.DeleteAsync(address.EntityId);
Assert.Equal(EntityState.Deleted, ctx.Entry(address).State);
}
using (var ctx = new AccountContext(options))
{
var accounts = new Repository <AccountModel>(ctx);
var account = await ctx.Accounts.FirstAsync();
await accounts.DeleteAsync(account.EntityId);
Assert.Equal(EntityState.Deleted, ctx.Entry(account).State);
}
}
public ActionResult Edit(int?id, string[] selectedRoles)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var userToUpdate = db.SysUsers.Include(u => u.SysUserRoles).Where(u => u.ID == id).Single();
if (TryUpdateModel(userToUpdate, "",
new string[] { "LoginName", "Email", "Password", "CreateDate", "SysDepartmentID" }))
{
try
{
UpdateUserRoles(selectedRoles, userToUpdate);
db.Entry(userToUpdate).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception)
{
throw;
}
}
return(View(userToUpdate));
}
public async Task <IActionResult> PutTransaction(string id, Transaction transaction)
{
if (id != transaction.Id)
{
return(BadRequest());
}
_context.Entry(transaction).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TransactionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult Edit(int?id, string[] selectRoles)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var userToUpdate = db.SysUsers.Include(t => t.SysUserRoles).Where(t => t.ID == id).SingleOrDefault();
if (TryUpdateModel(userToUpdate, "", new string[] { "LoginName", "Email", "Password", "CreateDate", "SysDepartmentID" }))
{
try
{
UpdateUserRoles(selectRoles, userToUpdate);
db.Entry(userToUpdate).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception)
{
throw;
}
}
//如果失败，重新绑定视图
PopulateDepartmentsDropDownList(userToUpdate.SysDepartmentID); //将用户所在部门选出
PopulateAssigenedRoleData(userToUpdate); //将某个用户下的所有角色选出
return(View(userToUpdate));
}
public async Task <User> Put(User user)
{
using (var db = new AccountContext())
{
db.Entry(user).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(user.UserId))
{
return(null);
}
else
{
throw;
}
}
return(user);
}
}
public async void Test_Repository_Update(string email, string city)
{
using (var ctx = new AccountContext(options))
{
var profiles = new Repository <ProfileModel>(ctx);
var profile = await ctx.Profiles.FirstAsync();
profile.Email = email;
profiles.Update(profile);
var result = ctx.Profiles.Find(profile.EntityId);
Assert.Equal(profile.Email, result.Email);
Assert.Equal(EntityState.Modified, ctx.Entry(result).State);
}
using (var ctx = new AccountContext(options))
{
var addresses = new Repository <AddressModel>(ctx);
var address = await ctx.Addresses.FirstAsync();
address.City = city;
addresses.Update(address);
var result = ctx.Addresses.Find(address.EntityId);
Assert.Equal(address.City, result.City);
Assert.Equal(EntityState.Modified, ctx.Entry(result).State);
}
}
public IHttpActionResult PutProfile(int id, Profile profile)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != profile.Id)
{
return(BadRequest());
}
db.Entry(profile).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ProfileExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> PutAccount(int id, Account account)
{
if (id != account.AccountNumber)
{
return(BadRequest());
}
_context.Entry(account).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AccountExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <User> ResetPassword(int id, string newPassword)
{
using (var db = new AccountContext())
{
if (!UserExists(id))
{
return(null);
}
var user = await db.Users.FindAsync(id);
user.Password = getHashedPassword(newPassword);
db.Entry(user).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(user.UserId))
{
return(null);
}
else
{
throw;
}
}
return(user);
}
}
public void UpdateBA(int BAnumber, int money)
{
var ba = _accountContext.BankAccounts.Find(BAnumber);
ba.RealBalance += money;
ba.AvailableBalance += money;
_accountContext.Entry(ba).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
_accountContext.SaveChanges();
}
public ActionResult Edit([Bind(Include = "ID,RoleName,RoleDesc")] SysRole sysRole)
{
if (ModelState.IsValid)
{
db.Entry(sysRole).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(sysRole));
}
public ActionResult Edit([Bind(Include = "Id,AccountNumber,CreationDate,Balance")] Account account)
{
if (ModelState.IsValid)
{
db.Entry(account).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(account));
}
public ActionResult Edit([Bind(Include = "Id,Kind")] OperationKind operationKind)
{
if (ModelState.IsValid)
{
db.Entry(operationKind).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(operationKind));
}
public ActionResult Edit([Bind(Include = "setNumberId,faramName,number")] setNumber setnumber)
{
if (ModelState.IsValid)
{
db.Entry(setnumber).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(setnumber));
}
public ActionResult Edit([Bind(Include = "bhuktaniPauneId,pauneKoNaam,address,code,phone,email,remarks,pauneType")] bhuktaniPaune bhuktanipaune)
{
if (ModelState.IsValid)
{
db.Entry(bhuktanipaune).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(bhuktanipaune));
}
public ActionResult Edit([Bind(Include = "Id,DepartmentName,DepartmentDesc")] SysDepartment sysDepartment)
{
if (ModelState.IsValid)
{
db.Entry(sysDepartment).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(sysDepartment));
}
public ActionResult Edit([Bind(Include = "dnId,vendorId,bibaran,rakam,subDate,nepFy,uptoDate,monthIndex")] dharautiNaamNamasi dharautinaamnamasi)
{
if (ModelState.IsValid)
{
db.Entry(dharautinaamnamasi).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.vendorId = new SelectList(db.vendors, "vendorId", "name", dharautinaamnamasi.vendorId);
return(View(dharautinaamnamasi));
}
public ActionResult Edit([Bind(Include = "Id,Country,Province,City,Street,numberHouse,ProfileId")] Address address)
{
if (ModelState.IsValid)
{
db.Entry(address).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Details", new { id = address.Id }));
}
ViewBag.ProfileId = new SelectList(db.Profiles, "Id", "Username", address.Profile.Id);
return(View(address));
}
public ActionResult Edit([Bind(Include = "ID,UserName,PassWord,Email,CreateDate,SysDepartmentId")] SysUser sysUser)
{
if (ModelState.IsValid)
{
db.Entry(sysUser).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.SysDepartmentId = new SelectList(db.SysDepartments, "Id", "DepartmentName", sysUser.SysDepartmentId);
return(View(sysUser));
}
public virtual void Update(T t, string[] propertys = null)
{
if (propertys != null)
{
DbSet.Attach(t);
foreach (var property in propertys)
{
db.Entry(t).Property(property).IsModified = true;
}
}
}
