public async Task <ActionResult> Edit(RoleModificationModel model)
{
IdentityResult result;
if (!ModelState.IsValid)
{
return(View("Error", new[] { "Role Not Found" }));
}
foreach (var userId in model.IdsToAdd ?? Enumerable.Empty <string>())
{
var user = await _userManager.FindByIdAsync(userId);
result = await _userManager.AddToRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
return(View("Error", result.Errors));
}
}
foreach (var userId in model.IdsToDelete ?? Enumerable.Empty <string>())
{
var user = await _userManager.FindByIdAsync(userId);
result = await _userManager.RemoveFromRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
return(View("Error", result.Errors));
}
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> ChangePassword(ChangePasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
AddErrors(result);
return(View(model));
}
public virtual async Task GetProfileDataAsync(ProfileDataRequestContext context)
{
var sub = context.Subject?.GetSubjectId();
if (sub == null)
{
throw new Exception("No sub claim present");
}
var user = await UserManager.FindByIdAsync(sub);
if (user == null)
{
Logger?.LogWarning("No user found matching subject Id: {0}", sub);
}
else
{
var principal = await ClaimsFactory.CreateAsync(user);
if (principal == null)
{
throw new Exception("ClaimsFactory failed to create a principal");
}
context.AddRequestedClaims(principal.Claims);
AddRoleClaims(context, principal);
}
}
public async Task <ActionResult> Edit()
{
var adminUser = await _userManager.FindByIdAsync(User.Id);
var model = BuildEditProfileViewModel(adminUser);
return(View(model));
}
public async Task <IActionResult> LoginAs(string id)
{
var user = await _userManager.FindByIdAsync(id);
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Profile(int id)
{
//Gets currently logged in user
AppUser currentUser = await _appUserManager.GetUserAsync(User);
//Returns List<Post> of user whose profile is being viewed, as split query,
//because of cartesian explosion
List <Post> userPosts = await _postRepository.GetAll()
.Where(p => p.AppUserId == id)
.Include(p => p.Post_Ingredients)
.ThenInclude(pi => pi.Ingredient)
.Include(p => p.AppUser)
.Include(p => p.Comments)
.ThenInclude(c => c.Commentator)
.OrderByDescending(p => p.TimeOfPosting)
.AsSplitQuery()
.AsNoTracking()
.ToListAsync();
//Convers Posts to PostsModel type
List <PostModel> userPostsModel = userPosts.ToPostModel()
.ToList();
#region Most efficient query for userPostsModel, use it when entity framework core 6.0 gets released!! AsSplitQuery() doesn't work on projections yet!!
//Most efficient query for postmodel, use it when entity framework core 6.0 gets released!! Don't forget to chain AsSplitQuery()!!
//var userPostsModel = _postRepository.GetAll()
// .Where(p => p.AppUserId == id)
// .ToPostModelTest()
// .ToList();
#endregion
//Gets the user whose profile is being viewed
AppUserModel userModelProfile = await _appUserManager.FindByIdAsync(id.ToString())
.ContinueWith(au => au.Result.ToAppUserModelBaseInfo());
//Checks and sets bool if current user is following the one whose profile is being viewed
userModelProfile.IsBeingFollowed = _user_FollowsRepository.GetAll()
.Any(u => u.FollowerId == currentUser.Id && u.FollowsId == id);
//Gets all the posts which current user has liked from user whose profile he is visiting
List <Yummy_Post> currentUsersYummedPosts = await _yummy_PostRepository.GetAll()
.Where(yp => yp.AppUserId == currentUser.Id && yp.PostAppUserId == id)
.ToListAsync();
//Sets IsPostYummed property if current user has already liked the post, would probably be the best to denormalize database instead of doing this
foreach (var yummedPost in currentUsersYummedPosts)
{
userPostsModel.SingleOrDefault(p => p.Id == yummedPost.PostId).IsPostYummed = true;
}
//To pass necessary data for view
ViewBag.UserProfile = userModelProfile;
ViewBag.CurrentUser = currentUser;
return(View(userPostsModel));
}
public async Task <ActionResult> Details(string id)
{
AppUser user = await _userManager.FindByIdAsync(id);
if (user != null)
{
UserAdminViewModel viewModel = Mapper.Map <UserAdminViewModel>(user);
return(View(viewModel));
}
return(Redirect("Index"));
}
public async Task <IActionResult> Update(string id)
{
AppUser user = await userManager.FindByIdAsync(id);
if (user != null)
{
return(View(user));
}
else
{
return(RedirectToAction("Index"));
}
}
public ActionResult Edit(long adminId)
{
AppUser user = userManager.FindByIdAsync(adminId).Result;
var roles = roleManager.Roles.ToList();
AdminUserEditModel model = new AdminUserEditModel {
AdminId = user.Id,
UserName = user.UserName,
Password = user.PasswordHash,
Roles = roles
};
return(View(model));
}
public async Task <Boolean> BeforeSave(Int64 UserId, Object beforeData)
{
var before = beforeData as ExpandoObject;
var userId = before.Eval <Int64>("User.Id");
var pwd = before.Eval <String>("User.Password");
var token = await _userManager.GeneratePasswordResetTokenAsync(userId);
var ir = await _userManager.ResetPasswordAsync(userId, token, pwd);
if (!ir.Succeeded)
{
String errors = String.Empty;
foreach (var e in ir.Errors)
{
errors += "\n" + e;
}
throw new SecurityException("Set password failed." + errors);
}
var user = await _userManager.FindByIdAsync(userId);
await _userManager.UpdateAsync(user);
return(true);
}
//[Authorize(Roles ="DeleteUser")]
public async Task <HttpResponseMessage> Delete(HttpRequestMessage request, string id)
{
var identity = (ClaimsIdentity)User.Identity;
IEnumerable <Claim> claims = identity.Claims;
var appUser = await AppUserManager.FindByIdAsync(id);
var result = await AppUserManager.DeleteAsync(appUser);
if (result.Succeeded)
{
Log log = new Log()
{
AppUserId = claims.FirstOrDefault().Value,
Content = Notification.DELETE_USER,
Created = DateTime.Now
};
_logService.Create(log);
_logService.Save();
return(request.CreateResponse(HttpStatusCode.OK, id));
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.OK, string.Join(",", result.Errors)));
}
}
/// <summary>
/// Handle user update.
/// </summary>
/// <param name="command">Command.</param>
public async Task HandleUpdateUser(UpdateUserCommand command)
{
var user = await userManager.FindByIdAsync(command.UserId);
if (user == null)
{
throw new NotFoundException("User not found.");
}
user.Email = command.Email;
user.UserName = command.Email;
user.FirstName = command.FirstName;
user.LastName = command.LastName;
user.Country = command.Country;
user.City = command.City;
user.UpdatedAt = DateTime.Now;
user.Clean();
command.Result = await userManager.UpdateAsync(user);
if (!command.Result.Succeeded)
{
throw new IdentityException(command.Result);
}
command.HasPassword = userManager.SupportsUserPassword;
}
public async Task <HttpResponseMessage> ChangePassword(HttpRequestMessage request, string id, string password, string newPassword)
{
if (User != null && MemoryCacheHelper.RemoveUserEditByAdmin(User.Identity.Name))
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, CommonConstants.Error_Edit_By_Admin));
}
if (!string.IsNullOrEmpty(id))
{
var appUser = await AppUserManager.FindByIdAsync(id);
if (appUser != null)
{
bool passwordCheck = await AppUserManager.CheckPasswordAsync(appUser, password);
if (passwordCheck)
{
var result = await AppUserManager.ChangePasswordAsync(appUser.Id, password, newPassword);
return(request.CreateResponse(HttpStatusCode.OK, Common.Constants.MessageSystem.ChangePasswordSuccess));
}
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, Common.Constants.MessageSystem.ErrorOldPassword));
}
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, Common.Constants.MessageSystem.UserNotFound));
}
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, Common.Constants.MessageSystem.ErrorIdNull));
}
public async Task <IHttpActionResult> ResetPassword(JObject value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
dynamic data = value;
var pass = (string)data.pass;
var code = (string)data.code;
var userId = (string)data.userId;
//code = HttpUtility.UrlDecode(code);
var user = await AppUserManager.FindByIdAsync(userId);
if (user == null)
{
return(BadRequest("El usuario es incorrecto."));
}
var result = await AppUserManager.ResetPasswordAsync(user.Id, code, pass);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest("El enlace de recuperación ya no es valido."));
}
public static MvcHtmlString GetUserNameAndName(this HtmlHelper html, long id)
{
AppUserManager mgr = HttpContext.Current.GetOwinContext().GetUserManager <AppUserManager>();
var user = mgr.FindByIdAsync(id).Result;
return(new MvcHtmlString(string.Format("{0}", user.UserName)));
}
public HttpResponseMessage Details(HttpRequestMessage request, string id)
{
if (string.IsNullOrEmpty(id))
{
return(request.CreateResponse(HttpStatusCode.BadRequest, nameof(id) + Common.Constants.MessageSystem.NoValues));
}
var group = _groupService.GetGroupById(id);
if (group == null)
{
return(request.CreateResponse(HttpStatusCode.NoContent, Common.Constants.MessageSystem.NoData));
}
else
{
var groupViewModel = Mapper.Map <Group, GroupViewModel>(group);
var groupLeadID = _groupService.GetGroupLeadIdByGroup(group.ID);
if (groupLeadID != null)
{
groupViewModel.GroupLead = AppUserManager.FindByIdAsync(groupLeadID).Result.FullName;
}
else
{
groupViewModel.GroupLead = CommonConstants.DefaultGroupLeader;
}
return(request.CreateResponse(HttpStatusCode.OK, groupViewModel));
}
}
public IHttpActionResult ConfirmPasswordRecovery(Guid userId, string newPassword = "", string code = "")
{
if (string.IsNullOrWhiteSpace(code))
{
Logger.ServiceLog.Warn($"Пользователь {userId} не указал код.");
return(GetErrorFromModel("code", "Требуется код."));
}
var user = AppUserManager.FindByIdAsync(userId);
if (user == null)
{
Logger.ServiceLog.Warn($"Пользователь с id {userId} не зарегистрирован.");
GetErrorFromModel("userId", $"Пользователь с id {userId} не зарегистрирован.");
}
code = HttpUtility.UrlDecode(code);
var result = AppUserManager.ResetPassword(userId, code, newPassword);
if (result.Succeeded)
{
Logger.ServiceLog.Info($"Пользователю {userId} успешно изменил пароль.");
return(Ok());
}
Logger.ServiceLog.Warn($"Пользователь с id {userId} не смог изменить пароль.");
return(GetErrorResult(result));
}
public async Task <ActionResult> VerifyEmailRequest()
{
var userId = User.Id;
//
if (await _appUserManager.IsEmailConfirmedAsync(userId))
{
return(RedirectToAction(nameof(VerifyEmail), new { status = AccountActionStatus.VerifyEmailResponseSuccess.ToLowerCaseString() }));
}
//
var adminUser = await _appUserManager.FindByIdAsync(userId);
var mailModel = new AccountVerifyEmailMessageViewModel()
{
Name = adminUser.FullName ?? adminUser.UserName,
PageTitle = GetLocalizedString <AreaResources>("VerifyEmail"),
ConfirmationLink = Url.Action("VerifyEmailResponse", "Account", new
{
verifyToken = await _appUserManager.GenerateEmailConfirmationTokenAsync(adminUser.Id)
}, protocol: Request.Url.Scheme)
};
var subject = $"[{GetLocalizedString("AppName")}] {mailModel.PageTitle}";
var message = RenderViewToString("VerifyEmailMessage", model: mailModel);
_emailDispatcherService.Dispatch(message, subject, new MailAddress(adminUser.Email, adminUser.FullName));
return(RedirectToAction(nameof(VerifyEmail), new { status = AccountActionStatus.VerifyEmailRequestSent.ToLowerCaseString() }));
}
public async Task <IHttpActionResult> GetUser(Guid id)
{
var user = await AppUserManager.FindByIdAsync(id);
return(user != null?Ok(TheModelFactory.Create(user))
: GetErrorFromModel("id", "Не удается найти пользователя"));
}
public async Task <RepositoryResult <IEnumerable <MakerInterfaceModel> > > SetMakersByUSerIdAsync(int userId, List <MakerInterfaceModel> setMakers)
{
try
{
if (userId <= 0)
{
return(new RepositoryResult <IEnumerable <MakerInterfaceModel> >(HttpStatusCode.BadRequest));
}
var user = await AppUserManager.FindByIdAsync(userId);
if (user == null)
{
return(new RepositoryResult <IEnumerable <MakerInterfaceModel> >(HttpStatusCode.NotFound));
}
using (DataContext dbContext = DataContext.Create())
{
dbContext.Database.ExecuteSqlCommand(RepositoryResource.IncrementResetUserMaker);
using (DbContextTransaction tx = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
var setMakerIds = setMakers.Select(m => m.Id).OrderBy(x => x).ToList();
var makerIds = dbContext.MakerModels.Select(x => x.Id).OrderBy(x => x).ToList <int>();
IQueryable <UserMakerModel> userMakers = dbContext.UserMakerModels.Where(x => x.UserModelId == userId).OrderBy(x => x.MakerModelId);
foreach (int item in makerIds)
{
UserMakerModel check = userMakers.Where(x => x.MakerModelId == item).FirstOrDefault();
if (check == null && setMakerIds.Contains(item))
{
check = new UserMakerModel();
check.UserModelId = userId;
check.MakerModelId = item;
dbContext.UserMakerModels.Add(check);
}
else if (check != null && setMakerIds.Contains(item) && check.Deleted == true)
{
check.Deleted = false;
dbContext.Entry(check).State = EntityState.Modified;
}
else if (check != null && !setMakerIds.Contains(item) && check.Deleted == false)
{
check.Deleted = true;
dbContext.Entry(check).State = EntityState.Modified;
}
}
dbContext.SaveChanges();
tx.Commit();
}
dbContext.Database.ExecuteSqlCommand(RepositoryResource.IncrementResetUserMaker);
return(new RepositoryResult <IEnumerable <MakerInterfaceModel> >(HttpStatusCode.OK, setMakers));
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <RepositoryResult <IEnumerable <MakerInterfaceModel> > > GetMakersByUserIdAsync(int userId)
{
try
{
if (userId <= 0)
{
return(new RepositoryResult <IEnumerable <MakerInterfaceModel> >(HttpStatusCode.BadRequest));
}
var user = await AppUserManager.FindByIdAsync(userId);
if (user == null)
{
return(new RepositoryResult <IEnumerable <MakerInterfaceModel> >(HttpStatusCode.NotFound));
}
using (var repository = new MakerRepository())
{
var makerlist = repository.GetMakersByUserIdForInterface(userId);
if (makerlist == null)
{
return(new RepositoryResult <IEnumerable <MakerInterfaceModel> >(HttpStatusCode.NotFound));
}
return(new RepositoryResult <IEnumerable <MakerInterfaceModel> >(HttpStatusCode.OK, makerlist));
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <RepositoryResult <UserInterfaceModel> > CreateUserAsync(UserInterfaceModel createUser)
{
try
{
if (await AppUserManager.FindByIdAsync(createUser.Id) != null)
{
return(new RepositoryResult <UserInterfaceModel>(HttpStatusCode.Conflict));
}
if (string.IsNullOrWhiteSpace(createUser.NewPassword))
{
return(new RepositoryResult <UserInterfaceModel>(HttpStatusCode.BadRequest, "パスワードは必須項目です。"));
}
var user = new UserModel();
user.UserName = createUser.UserName;
user.Name = createUser.Name;
user.Email = createUser.Email;
user.Enabled = createUser.Enabled;
var result = new RepositoryResult <UserInterfaceModel>(HttpStatusCode.Created);
result.identityResult = await AppUserManager.CreateAsync(user, createUser.NewPassword);
if (!result.identityResult.Succeeded)
{
result.Code = HttpStatusCode.BadRequest;
}
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IHttpActionResult> ConfirmEmail(Guid userId, string code = "")
{
if (string.IsNullOrWhiteSpace(code))
{
Logger.ServiceLog.Warn($"Пользователь {userId} не указал код.");
return(GetErrorFromModel("code", "Требуется код."));
}
var user = await AppUserManager.FindByIdAsync(userId);
if (user == null)
{
Logger.ServiceLog.Warn($"Пользователь с {userId} не зарегистрирован в БД");
return(GetErrorFromModel("userId", "Такого пользователя не существует."));
}
code = HttpUtility.UrlDecode(code);
var result = await AppUserManager.ConfirmEmailAsync(userId, code);
if (result.Succeeded)
{
Logger.ServiceLog.Info($"Пользователь {user.Id} успешно подтвердил аккаунт.");
return(Ok());
}
Logger.ServiceLog.Warn($"Пользователь с {userId} не подтвердил аккаунт");
return(GetErrorResult(result));
}
public async Task <IHttpActionResult> Me()
{
var userId = User.Identity.GetUserId();
var user = await AppUserManager.FindByIdAsync(userId);
return(Ok(TheModelFactory.Create(user)));
}
public async Task AfterSave(Object beforeData, Object afterData)
{
var before = beforeData as ExpandoObject;
var after = afterData as ExpandoObject;
var userId = after.Eval <Int64>("User.Id");
var pwd = before.Eval <String>("User.Password");
var token = await _userManager.GeneratePasswordResetTokenAsync(userId);
var ir = await _userManager.ResetPasswordAsync(userId, token, pwd);
if (!ir.Succeeded)
{
String errors = String.Empty;
foreach (var e in ir.Errors)
{
errors += "\n" + e;
}
throw new SecurityException("Set password failed." + errors);
}
var user = await _userManager.FindByIdAsync(userId);
user.EmailConfirmed = true;
user.SetModified(UserModifiedFlag.EmailConfirmed);
await _userManager.UpdateAsync(user);
}
public static MvcHtmlString GetUserName(this HtmlHelper html, string id)
{
AppUserManager mgr
= HttpContext.Current.GetOwinContext().GetUserManager <AppUserManager>();
return(new MvcHtmlString(mgr.FindByIdAsync(id).Result.UserName));
}
public async Task <HttpResponseMessage> SendMailMulti(HttpRequestMessage request, [FromBody] List <SendMailModel> sendMailModel)
{
Func <HttpResponseMessage> func = () =>
{
foreach (var items in sendMailModel)
{
string Body = "";
string BodyInDelegate = "";
string BodyCreateExplan = "";
bool resultsendmailDelegate = true;
string FullName = "";
if (items.Action.Equals(CommonConstants.StatusRejected.ToLower()))
{
Body = _systemService.getBodyMail(MailConsstants.TemplateRejectMail, items.Title, AppUserManager.FindByIdAsync(items.CreateBy).Result.FullName, items.Action, items.EmailType, items.ReasonReject, items.Category, null, null, null, null, null, items.OTDate, items.OTDateType, items.OTTimeType, items.StartTime, items.EndTime, items.ExplanationDate, items.ExplanationReason, items.Actual, items.Description, FullName);
}
else if (items.Action.Equals(CommonConstants.StatusCancelled.ToLower()))
{
Body = _systemService.getBodyMail(MailConsstants.TemplateSendMailAuto, items.Title, AppUserManager.FindByIdAsync(items.CreateBy).Result.FullName, items.Action, items.EmailType, null, items.Category, null, null, null, null, null, items.OTDate, items.OTDateType, items.OTTimeType, items.StartTime, items.EndTime, items.ExplanationDate, items.ExplanationReason, items.Actual, items.Description, FullName);
}
else if (items.Action.Equals(CommonConstants.StatusDelegation.ToLower()))
{
Body = _systemService.getBodyMail(MailConsstants.TemplateDelegationToMember, items.Title, AppUserManager.FindByIdAsync(items.CreateBy).Result.FullName, items.Action, items.EmailType, null, items.Category, null, null, null, null, null, items.OTDate, items.OTDateType, items.OTTimeType, items.StartTime, items.EndTime, items.ExplanationDate, items.ExplanationReason, items.Actual, items.Description, FullName);
items.toEmail = new string[] { AppUserManager.FindByIdAsync(items.toEmail[0]).Result.Email };
}
else
{
Body = _systemService.getBodyMail(MailConsstants.TemplateSendMailAuto, items.Title, AppUserManager.FindByIdAsync(items.CreateBy).Result.FullName, items.Action, items.EmailType, null, items.Category, items.GroupName, items.RequestTypeName, items.DetailReason, items.StartDate, items.EndDate, items.OTDate, items.OTDateType, items.OTTimeType, items.StartTime, items.EndTime, items.ExplanationDate, items.ExplanationReason, items.Actual, items.Description, FullName);
}
var result = _systemService.SendMail(items.toEmail, items.ccMail, items.EmailSubject, Body);
}
return(request.CreateResponse(HttpStatusCode.OK, true));
};
return(await CreateHttpResponse(request, func));
}
public async Task <Object> InvokeAsync(Int32 TenantId, Int64 UserId, Int64 Id, ExpandoObject User)
{
if (!_host.IsMultiTenant)
{
throw new InvalidOperationException("CreateTenantUserHandleris available only in multitenant environment");
}
User.Set("Tenant", TenantId);
await _dbContext.ExecuteExpandoAsync(_host.CatalogDataSource, "a2security.[CreateUserSimple]", User);
Int64 userId = User.Get <Int64>("Id");
var token = await _userManager.GeneratePasswordResetTokenAsync(userId);
var identityResult = await _userManager.ResetPasswordAsync(userId, token, User.Get <String>("Password"));
if (!identityResult.Succeeded)
{
throw new InvalidOperationException(String.Join(",", identityResult.Errors));
}
var newAppUser = await _userManager.FindByIdAsync(userId);
await _dbContext.ExecuteAsync <AppUser>(_host.TenantDataSource, "a2security.CreateTenantUser", newAppUser);
var result = new ExpandoObject();
result.Set("Id", userId);
return(result);
}
public async Task <IHttpActionResult> GetApplicationUser(string id)
{
var user = await AppUserManager.FindByIdAsync(id);
var coachRole = AppRoleManager.FindByName("Coach");
if (user == null)
{
return(NotFound());
}
var response = new GetUserResponse
{
Item = new UserHttpResponse
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
IsCoach = user.Roles.Any(j => j.RoleId == coachRole.Id),
Email = user.UserName,
RoleIds = user.Roles.Select(i => i.RoleId).ToList(),
Timezone = user.Timezone,
CVLink = user.CVLink,
Webex = user.Webex,
},
};
response.UsageCount = AppDb.CoachingPrograms
.Count(i =>
i.Coach.Id == id ||
i.Coachee.Id == id);
return(Ok(response));
}
//[Permission(Action = "Update", Function = "USER")]
public async Task <HttpResponseMessage> UpdateProfile(HttpRequestMessage request, AppUserViewModel applicationUserViewModel)
{
if (ModelState.IsValid)
{
var appUser = await AppUserManager.FindByIdAsync(applicationUserViewModel.Id);
try
{
appUser.UpdateUser(applicationUserViewModel);
var result = await AppUserManager.UpdateAsync(appUser);
if (result.Succeeded)
{
var userRoles = await AppUserManager.GetRolesAsync(appUser.Id);
var selectedRole = applicationUserViewModel.Roles.ToArray();
selectedRole = selectedRole ?? new string[] { };
await AppUserManager.RemoveFromRolesAsync(appUser.Id, userRoles.ToArray());
await AppUserManager.AddToRolesAsync(appUser.Id, selectedRole.ToArray());
return(request.CreateResponse(HttpStatusCode.OK, applicationUserViewModel));
}
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, Common.Constants.MessageSystem.MessageDuplicateEmail));
}
catch (NameDuplicatedException dex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message));
}
}
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
private static async Task<AppUser> GetTargetUser(OAuthGrantCustomExtensionContext context, AppUserManager repo) {
string targetUserIdString = context.Parameters["userid"];
int targetUserId;
Int32.TryParse(targetUserIdString, out targetUserId);
var targetUser = await repo.FindByIdAsync(targetUserId);
return targetUser;
}
