public IHttpActionResult PutiMentorUser(int id, iMentorUser iMentorUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != iMentorUser.Id)
{
return(BadRequest());
}
db.Entry(iMentorUser).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!iMentorUserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void UpdateUserTest()
{
ManageController controller = new ManageController();
iMentorUser user = controller.ReturnLastAddedUser();
iMentorUserInfo userInfo = new iMentorUserInfo();
userInfo.Id = user.Id;
userInfo.UserName = "******";
userInfo.Email = user.Email;
userInfo.RoleId = user.RoleId;
userInfo.Role = userInfo.GetRoleByUser(user);
//Check that the UpdateUser function completed successfully
Assert.AreEqual(controller.UpdateUser(userInfo), "User Updated");
//Check that the user was actually updated in the database
iMentorUser userUpdated = controller.ReturnLastAddedUser();
Assert.IsTrue(userUpdated.Id == userInfo.Id &&
userUpdated.UserName == userInfo.UserName &&
userUpdated.Email == userInfo.Email &&
userUpdated.RoleId == userInfo.RoleId);
//Clean up
userInfo.UserName = user.UserName;
controller.UpdateUser(userInfo);
}
public int GetRoleIdByUser(iMentorUser user)
{
using (iMAST_dbEntities db = new iMAST_dbEntities())
{
var userRole = db.iMentorUserRoles.Where(x => x.UserId == user.Id).FirstOrDefault();
var result = userRole.RoleId;
return(result);
}
}
public IHttpActionResult GetiMentorUser(int id)
{
iMentorUser iMentorUser = db.iMentorUsers.Find(id);
if (iMentorUser == null)
{
return(NotFound());
}
return(Ok(iMentorUser));
}
public string GetRoleName(iMentorUser user)
{
using (iMAST_dbEntities db = new iMAST_dbEntities())
{
var userRole = db.iMentorUserRoles.Where(x => x.UserId == user.Id).FirstOrDefault();
var role = db.iMentorRoles.Where(x => x.Id == userRole.RoleId).FirstOrDefault();
var result = role.RoleName;
return(result);
}
}
public IHttpActionResult PostiMentorUser(iMentorUser iMentorUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.iMentorUsers.Add(iMentorUser);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = iMentorUser.Id }, iMentorUser));
}
public IHttpActionResult DeleteiMentorUser(int id)
{
iMentorUser iMentorUser = db.iMentorUsers.Find(id);
if (iMentorUser == null)
{
return(NotFound());
}
db.iMentorUsers.Remove(iMentorUser);
db.SaveChanges();
return(Ok(iMentorUser));
}
public override bool IsUserInRole(string username, string roleName)
{
using (iMAST_dbEntities db = new iMAST_dbEntities())
{
iMentorUser user = db.iMentorUsers.FirstOrDefault(u => u.UserName.Equals(username, StringComparison.CurrentCultureIgnoreCase) || u.Email.Equals(username, StringComparison.CurrentCultureIgnoreCase));
iMentorUserRole userRole = db.iMentorUserRoles.FirstOrDefault(x => x.UserId == user.Id);
iMentorRole role = db.iMentorRoles.FirstOrDefault(x => x.Id == userRole.RoleId);
var roles = new string[] { role.RoleName };
if (user != null)
{
return(roles.Any(r => r.Equals(roleName, StringComparison.CurrentCultureIgnoreCase)));
}
else
{
return(false);
}
}
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
//Create the iMentorUser entry
using (iMAST_dbEntities db = new iMAST_dbEntities())
{
bool userExists = false;
foreach (iMentorUser u in db.iMentorUsers.ToList())
{
if (u.Email.Equals(user.Email))
{
userExists = true;
}
}
//Create the user
if (!userExists)
{
var imUser = new iMentorUser();
imUser.UserName = user.UserName;
imUser.Email = user.Email;
imUser.UrlId = GetNewUrlId();
db.iMentorUsers.Add(imUser);
db.SaveChanges();
//Create the Role
var imUserRole = new iMentorUserRole();
imUserRole.UserId = imUser.Id;
imUserRole.RoleId = db.iMentorRoles.Where(x => x.RoleName.Equals("Read Only")).FirstOrDefault().Id; //Default role is "Read Only"
db.iMentorUserRoles.Add(imUserRole);
db.SaveChanges();
}
}
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home"));
}
}
AddErrors(result);
}
//ViewBag.ReturnUrl = returnUrl;
//return View(model);
return(RedirectToAction("Index", "Home"));
}
