/// <summary>
/// Saves user details provided while signup
/// </summary>
public void SaveUserDetails(AspNetUser addedUser, RegisterViewModel model)
{
UserDetail user = userDetailsRepository.Create();
user.AccountType = model.AccountType;
user.Address = model.CompanyAddress;
user.CompanyName = model.CompanyName;
user.CountryName = model.CountryName;
user.CompanyShortUrl = model.ShortUrl;
user.UserId = addedUser.Id;
userDetailsRepository.Add(user);
userDetailsRepository.SaveChanges();
}
/// <summary>
/// Set User Permission
/// </summary>
private void SetUserPermissions(AspNetUser user, ClaimsIdentity identity)
{
IList<MenuRight> menuRights;
if (user.AspNetRoles == null || user.AspNetRoles.Count < 1)
{
return;
}
if (user.AspNetRoles.Any(roles => roles.Name == CaresApplicationRoles.SystemAdministrator))
{
menuRights = user.AspNetRoles.FirstOrDefault(roles => roles.Name == CaresApplicationRoles.SystemAdministrator).MenuRights.ToList();
}
else if (user.AspNetRoles.Any(roles => roles.Name == CaresApplicationRoles.Admin))
{
menuRights = user.AspNetRoles.FirstOrDefault(roles => roles.Name == CaresApplicationRoles.Admin).MenuRights.ToList();
}
else
{
menuRights = user.AspNetRoles.FirstOrDefault().MenuRights.ToList();
}
IEnumerable<string> PermissionKeyClaims=menuRights.Select(menuRight => menuRight.CreatePermissionKey());
ClaimHelper.AddClaim(new Claim(CaresUserClaims.UserPermissionSet, JsonConvert.SerializeObject(PermissionKeyClaims)), identity);
}
/// <summary>
/// Add User
/// </summary>
private string AddUserToUserManager(AspNetUser user, UserManagement model)
{
var result = UserManager.Create(user, model.Password);
if (result.Succeeded)
{
var addUserToRoleResult = UserManager.AddToRole(user.Id, model.UserRole);
if (!addUserToRoleResult.Succeeded)
{
throw new InvalidOperationException(string.Format("Failed to add user to role {0}",
model.UserRole));
}
}
return result.Errors.FirstOrDefault();
}
public ActionResult CreateUser(UserManagement model)
{
if (model == null)
throw new InvalidOperationException("User Does not exists!");
var domainKeyClaim = ClaimHelper.GetClaimToString(CaresUserClaims.UserDomainKey);
if (domainKeyClaim == null)
{
throw new InvalidOperationException("Domain-Key claim not found!");
}
var domainkey = System.Convert.ToInt64(domainKeyClaim.Value);
// Creating employee
//DomainModels.Employee emp = employeeService.CreateEmployeeWithUser(model.UserEmail);
var user = new AspNetUser
{
PhoneNumber = model.PhoneNumber,
UserName = model.UserEmail,
Email = model.UserEmail,
UserDomainKey = domainkey,
FirstName = model.FirstName,
LastName = model.LastName
};
var status = AddUserToUserManager(user, model);
if (status == null)
return RedirectToAction("Index");
var roles = RoleManager.Roles.Where(role => role.Name != "SystemAdministrator").ToList();
var allUsers = GetAllUsers().ToList();
//var allEmployees = employeeService.GetAllForUser(allUsers.Select(usr => usr.EmployeeId).ToList()).Select(employee => employee.CreateFrom());
ViewBag.UserRoles = roles;
//ViewBag.Employees = allEmployees;
ViewBag.UserError = status;
return View(new UserManagement());
}
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 AspNetUser { UserName = model.Email, Email = model.Email };
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
return RedirectToLocal(returnUrl);
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new AspNetUser { UserName = model.Email, Email = model.Email };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var addUserToRoleResult = await UserManager.AddToRoleAsync(user.Id, model.SelectedRole);
if (!addUserToRoleResult.Succeeded)
{
throw new InvalidOperationException(string.Format("Failed to add user to role {0}", model.SelectedRole));
}
var code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code },
protocol: Request.Url.Scheme);
await
UserManager.SendEmailAsync(model.Email, "Confirm your account", "\">link</a><br>Your Password is:" + model.Password);
ViewBag.Link = callbackUrl;
return View("DisplayEmail");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return View(model);
}
private async Task SignInAsync(AspNetUser user, bool isPersistent)
{
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie, DefaultAuthenticationTypes.TwoFactorCookie);
AuthenticationManager.SignIn(new AuthenticationProperties { IsPersistent = isPersistent }, await user.GenerateUserIdentityAsync(UserManager,
DefaultAuthenticationTypes.ApplicationCookie));
}
