public async Task <IActionResult> Update(UserClaimModel model)
{
var claim = new Claim(model.ClaimValue, model.ClaimValue);
if (string.IsNullOrEmpty(model.Id))
{
return(Json(false));
}
var user = await userManager.FindByIdAsync(model.Id);
if (user == null)
{
return(Json(false));
}
if (model.Add)
{
if (userManager.GetClaimsAsync(user).Result.Any(x => x.Type == model.ClaimValue))
{
return(Json(true));
}
var result = await userManager.AddClaimAsync(user, claim);
return(Json(result.Succeeded));
}
else
{
var result = await userManager.RemoveClaimAsync(user, claim);
return(Json(result.Succeeded));
}
}
public Messages Save(ContentEntity model, UserClaimModel userClaim)
{
if (model != null && model.C_TITLE.IsNotNullOrEmpty() && model.C_SUBTITLE.IsNotNullOrEmpty() && model.C_SUMMARY.IsNotNullOrEmpty() && model.C_AUTHOR.IsNotNullOrEmpty() && model.C_SOURCE.IsNotNullOrEmpty() && model.C_CONTENT.IsNotNullOrEmpty())
{
model.C_TITLE = model.C_TITLE.HtmlEncode();
model.C_SUBTITLE = model.C_SUBTITLE.HtmlEncode();
model.C_IMAGEURL = model.C_IMAGEURL?.HtmlEncode() ?? "";
model.C_SUMMARY = model.C_SUMMARY.HtmlEncode();
model.C_AUTHOR = model.C_AUTHOR.HtmlEncode();
model.C_SOURCE = model.C_SOURCE.HtmlEncode();
model.C_KEYWORDS = model.C_KEYWORDS?.HtmlEncode() ?? "";
model.C_ADDUSERNAME = userClaim.UserName;
model.C_LASTEDITUSERNAME = userClaim.UserName;
int result = contentRepository.Save(model);
if (result > 0)
{
messages.Msg = "提交成功！！";
messages.Success = true;
}
else
{
messages.Msg = "提交失败！！";
}
}
else
{
messages.Msg = "请填写必填字段信息";
}
return(messages);
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
IdentityUser user = await userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("NotFound"));
}
List <Claim> allclaims = ClaimStorage.claims;
IList <Claim> userClaims = await userManager.GetClaimsAsync(user);
UserClaimModel userClaimModel = new UserClaimModel
{
UserId = userId
};
List <UserClaim> IssuedClaims = new List <UserClaim>();
foreach (Claim claim in allclaims)
{
UserClaim hashTable = new UserClaim();
hashTable.ClaimType = claim.Type;
if (userClaims.Any(x => x.Type == claim.Type))
{
hashTable.IsSelected = true;
}
IssuedClaims.Add(hashTable);
}
userClaimModel.Claims = IssuedClaims;
return(View(userClaimModel));
}
public Messages Save(AdvertEntity model, UserClaimModel userClaim)
{
if (model != null && model.A_TITLE.IsNotNullOrEmpty() && model.A_URL.IsNotNullOrEmpty())
{
model.A_PicUrl = model.A_PicUrl ?? "";
model.A_AddMan = userClaim.UserName;
model.A_SUMMARY = model.A_SUMMARY ?? "";
int result = advertRepository.Save(model);
if (result > 0)
{
messages.Msg = "保存成功！！";
messages.Success = true;
}
else if (result == -10000)
{
messages.Msg = "存在相同名称的数据";
}
else
{
messages.Msg = "保存失败！！";
}
}
else
{
messages.Msg = "请填写必填字段信息";
}
return(messages);
}
public async Task <IActionResult> ManageUserClaims(UserClaimModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {model.UserId} cannot be found";
return(View("NotFound"));
}
List <UserClaim> updateClaims = model.Claims;
IList <Claim> existingClaims = await userManager.GetClaimsAsync(user);
IdentityResult result = await userManager.RemoveClaimsAsync(user, existingClaims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot remove user existing claims");
return(View(model));
}
IEnumerable <Claim> updateClaimList = updateClaims.Where(x => x.IsSelected).Select(s => new Claim(s.ClaimType, s.ClaimType));
IdentityResult addresult = await userManager.AddClaimsAsync(user, updateClaimList);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot add selected claims to user");
}
return(View(model));
}
public ActionResult Aistatistik(UserClaimModel userClaimModel)
{
var a = _kankammisinContext.UserOperationClaims.Where(k => k.UserId == userClaimModel.userModel.Id);
if (a.FirstOrDefault().OperationClaimId == 2)
{
a.FirstOrDefault().OperationClaimId = 1;
userClaimModel.kullaniciTuru = "Admin";
}
else
{
a.FirstOrDefault().OperationClaimId = 2;
userClaimModel.kullaniciTuru = "Kullanici";
}
_kankammisinContext.SaveChanges();
var u = _kankammisinContext.Users.Find(userClaimModel.userModel.Id);
userClaimModel.userModel.kullaniciAdi = u.KullaniciAdi;
userClaimModel.userModel.ad = u.Ad;
userClaimModel.userModel.soyad = u.Soyad;
userClaimModel.userModel.email = u.Email;
userClaimModel.userModel.Id = u.ID;
return(RedirectToAction("Admin", "Admin"));
}
public UserClaimModel GetUserClaims()
{
var userId = User.Claims.FirstOrDefault(x => x.Type == "id").Value;
var model = new UserClaimModel()
{
UserId = Convert.ToInt32(userId)
};
return(model);
}
public static UserClaimModel GetUserClaims(string token)
{
var data = new JwtSecurityToken(token);
var userId = data.Payload.FirstOrDefault(x => x.Key == "id").Value.ToString();
var model = new UserClaimModel()
{
UserId = Convert.ToInt32(userId)
};
return(model);
}
public IActionResult UserSetup()
{
var principal = userProvider.GetPrincipal();
var claimModel = new UserClaimModel();
claimModel.Username = principal.Identity.Name;
claimModel.ClientAdmin = principal.FindFirst(c => c.Type == ConfigServerConstants.ClientAdminClaimType)?.Value ?? string.Empty;
claimModel.ReadClaims = string.Join(",", principal.FindAll(ConfigServerConstants.ClientReadClaimType).Select(s => s.Value));
claimModel.ConfiguratorClaim = string.Join(",", principal.FindAll(ConfigServerConstants.ClientConfiguratorClaimType).Select(s => s.Value));
return(View(claimModel));
}
public async Task <IActionResult> UserClaim(int id, int?page)
{
var pagedUserClaims = await _userService.GetPagedUserClaimAsync(id, page ?? 1);
ViewBag.PagedUserClaims = pagedUserClaims;
var model = new UserClaimModel
{
UserId = pagedUserClaims.UserId,
UserName = pagedUserClaims.UserName
};
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with {userId} can't be found";
return(View("NotFound"));
}
var existingUserClaims = await _userManager.GetClaimsAsync(user);
//ClaimIdentity--> UserClaimModel
var dataModel = new UserClaimModel
{
UserId = userId,
};
foreach (Claim claim in ClaimsStore.AllClaims)
{
var userClaim = new DataAccess.Models.UserClaim
{
ClaimType = claim.Type,
};
if (existingUserClaims.Any(x => x.Type == claim.Type && x.Value == "true"))
{
userClaim.IsSelected = true;
}
dataModel.Claims.Add(userClaim);
}
//UserClaimModel --> UserClaimViewModel
var model = new UserClaimViewModel
{
UserId = dataModel.UserId,
};
foreach (var item in dataModel.Claims)
{
var userclaim = new PicGallery.ViewModels.UserClaim
{
ClaimType = item.ClaimType,
IsSelected = item.IsSelected
};
model.Claims.Add(userclaim);
}
return(View(model));
}
/// <summary>
/// 获取当前登录用户编号
/// </summary>
/// <returns></returns>
public async Task <UserClaimModel> GetCurrentUserClaim()
{
UserClaimModel userClaimModel = new UserClaimModel();
int userId = 0;
var auth = await httpContextAccessor.HttpContext.AuthenticateAsync(CookieAuthenticationDefaults.AuthenticationScheme);
if (auth.Succeeded)
{
string[] info = auth.Principal.Identity.Name.Split("|||");
Int32.TryParse(info[0], out userId);
userClaimModel.UserName = info[1];
}
userClaimModel.UserId = userId;
return(userClaimModel);
}
public async Task <IActionResult> ManageUserClaims(UserClaimViewModel model)
{
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {model.UserId} cannot be found";
return(View("NotFound"));
}
//Get users existing claims and delete them
var claims = await _userManager.GetClaimsAsync(user);
var result = await _userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Canot remove existing user claims");
return(View(model));
}
//UserClaimViewModel--> UserClaimModel
var userModel = new UserClaimModel
{
UserId = model.UserId,
};
foreach (var item in model.Claims.Where(x => x.IsSelected))
{
var userclaim = new PicGallery.DataAccess.Models.UserClaim
{
ClaimType = item.ClaimType,
IsSelected = item.IsSelected
};
userModel.Claims.Add(userclaim);
}
result = await _userManager.AddClaimsAsync(user,
userModel.Claims.Select(c => new Claim(c.ClaimType, c.IsSelected? "true":"false")));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot add selected claims to user");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = model.UserId }));
}
public async Task <ExecutionResponse <object> > AddRemoveClaims(UserClaimModel claims, ClaimAction action)
{
try
{
var client = await GetClient(isCurrentClient : true);
var dtoString = JsonConvert.SerializeObject(claims);
StringContent httpContent = new StringContent(dtoString, Encoding.UTF8, "application/json");
var response = await client.PostAsync($"/account/{(action == ClaimAction.Add ? "addclaims" : "removeclaims")}", httpContent);
var result = await response.Content.ReadAsStringAsync();
var resObj = JsonConvert.DeserializeObject <object>(result);
if (response.IsSuccessStatusCode)
{
return(new ExecutionResponse <object>
{
Message = $"User claims {(action == ClaimAction.Add ? "added" : "removed")} successfully",
ResponseCode = ResponseCode.Ok,
ResponseData = resObj
});
}
else
{
return(new ExecutionResponse <object>
{
Message = $"{result}",
ResponseCode = ResponseCode.ServerException,
ResponseData = null
});
}
}
catch (Exception ex)
{
Log.Error(ex);
return(new ExecutionResponse <object>
{
Message = "An error occurred while processing your request",
ResponseCode = ResponseCode.ServerException,
ResponseData = null
});
}
}
public async Task <int> UpdateUserClaim(UserClaimModel model)
{
try
{
var storedProcedure = "dbo.UserClaim_Update";
return(await _dataGateway.Execute(storedProcedure,
new
{
Id = model.Id,
Type = model.Type,
Value = model.Value,
UserAccountId = model.UserAccountId
},
_connectionString.SqlConnectionString));
}
catch (SqlCustomException e)
{
throw new SqlCustomException("UserClaim could not be updated.", e.InnerException);
}
}
public IActionResult UserSetup(UserClaimModel claimModel)
{
var claims = new List <Claim>();
claims.Add(new Claim(UserProvider.username, claimModel.Username));
if (!string.IsNullOrWhiteSpace(claimModel.ClientAdmin))
{
claims.Add(new Claim(ConfigServerConstants.ClientAdminClaimType, claimModel.ClientAdmin));
}
if (!string.IsNullOrWhiteSpace(claimModel.ReadClaims))
{
claims.AddRange(claimModel.ReadClaims.Split(',').Select(s => new Claim(ConfigServerConstants.ClientReadClaimType, s)));
}
if (!string.IsNullOrWhiteSpace(claimModel.ConfiguratorClaim))
{
claims.AddRange(claimModel.ConfiguratorClaim.Split(',').Select(s => new Claim(ConfigServerConstants.ClientConfiguratorClaimType, s)));
}
userProvider.SetPrincipal(claims);
return(RedirectToAction(nameof(Index)));
}
public ActionResult Aistatistik(string kullaniciAdi)
{
UserClaimModel userClaimModel = new UserClaimModel();
var j = from uoc in _kankammisinContext.UserOperationClaims
join user in _kankammisinContext.Users on uoc.UserId equals user.ID
join o in _kankammisinContext.OperationClaims on uoc.OperationClaimId equals o.Id
where user.KullaniciAdi == kullaniciAdi
select new OperationClaim {
Id = uoc.OperationClaimId, Name = o.Name
};
List <string> uList = new List <string> {
"Admin", "Kullanici"
};
ViewBag.uList = new SelectList(uList);
userClaimModel.kullaniciTuru = j.FirstOrDefault().Name;
userClaimModel.userModel = _baseContext.Users.Where(k => k.kullaniciAdi == kullaniciAdi).FirstOrDefault();
return(View(userClaimModel));
}
public async Task <int> CreateUserClaim(UserClaimModel model)
{
try
{
var storedProcedure = "dbo.UserClaim_Create";
DynamicParameters p = new DynamicParameters();
p.Add("Type", model.Type);
p.Add("Value", model.Value);
p.Add("UserAccountId", model.UserAccountId);
p.Add("Id", DbType.Int32, direction: ParameterDirection.Output);
await _dataGateway.Execute(storedProcedure, p, _connectionString.SqlConnectionString);
return(p.Get <int>("Id"));
}
catch (SqlCustomException e)
{
throw new SqlCustomException("UserClaim could not be created.", e.InnerException);
}
}
public async Task <IActionResult> UserClaim(UserClaimModel model)
{
if (!ModelState.IsValid)
{
var pagedUserClaims = await _userService.GetPagedUserClaimAsync(model.UserId, 1);
ViewBag.PagedUserClaims = pagedUserClaims;
return(View(model));
}
var isExistsUserClaim = await _userService.IsUserClaimExistsAsync(model.UserId, model.ClaimType, model.ClaimValue);
if (isExistsUserClaim)
{
CreateNotification(NotificationHelper.AlertType.Info, await _localizationService.GetResourceAsync("UserClaims.Exists"));
return(RedirectToAction(nameof(UserClaim), new { id = model.UserId }));
}
await _userService.InsertUserClaimAsync(CommonMappers.Mapper.Map <UserClaim>(model));
SuccessNotification(await _localizationService.GetResourceAsync("UserClaims.Added"));
return(RedirectToAction(nameof(UserClaim), new { id = model.UserId }));
}
public async Task <IActionResult> DeleteUserClaim(UserClaimModel model)
{
var userClaim = await _userService.GetUserClaimByIdAsync(model.Id);
if (userClaim == null)
{
return(RedirectToAction(nameof(UserClaim), new { id = model.UserId }));
}
if (userClaim.UserId != model.UserId)
{
return(RedirectToAction(nameof(UserClaim), new { id = model.UserId }));
}
var deletedResult = await _userService.DeleteUserClaimByIdAsync(model.Id);
if (deletedResult)
{
SuccessNotification(await _localizationService.GetResourceAsync("UserClaims.Deleted"));
return(RedirectToAction(nameof(UserClaim), new { id = model.UserId }));
}
return(View(model));
}
public async Task <Result <int> > RegisterAccount(WebUserAccountModel accountModel,
WebUserProfileModel userModel, string password, string ipAddress)
{
try
{
// Create Result to determine the result and message the UI will present
var resultModel = new Result <int>();
if (accountModel.Username == null || accountModel.EmailAddress == null || userModel.FirstName == null ||
userModel.Surname == null || userModel.DateOfBirth == null || password == null)
{
resultModel.WasSuccessful = false;
resultModel.ErrorMessage = ErrorMessage.Null;
Console.WriteLine("Register user failed: " + resultModel.ErrorMessage.ToString());
return(resultModel);
}
else if (password.Length >= 8 && password.Any(char.IsDigit) &&
password.Any(char.IsUpper) && password.Any(char.IsLower))
{
var usernameAlreadyExists = await _validationService.UsernameExists(accountModel.Username);
if (usernameAlreadyExists)
{
// Log and return Username existing result
_logger.Log(ErrorMessage.UsernameExists.ToString(), LogTarget.All, LogLevel.error, this.ToString(), "User_Logging");
resultModel.WasSuccessful = false;
resultModel.ErrorMessage = ErrorMessage.UsernameExists;
Console.WriteLine("Register user failed: " + resultModel.ErrorMessage.ToString());
return(resultModel);
}
var emailAlreadyExists = await _validationService.EmailExists(accountModel.EmailAddress);
if (emailAlreadyExists)
{
// Log and return Email existing result
_logger.Log(ErrorMessage.EmailExists.ToString(), LogTarget.All, LogLevel.error, this.ToString(), "User_Logging");
resultModel.WasSuccessful = false;
resultModel.ErrorMessage = ErrorMessage.EmailExists;
Console.WriteLine("Register user failed: " + resultModel.ErrorMessage.ToString());
return(resultModel);
}
// Creates User Account and gets Account ID to pass along
var accountID = await _userAccountService.CreateAccount(accountModel);
// Sets the password for the new Account
await _cryptographyService.newPasswordEncryptAsync(password, accountID);
await _publicUserProfileService.CeatePublicUserProfileAsync(new PublicUserProfileModel()
{
UserId = accountID
});
// Passes on the Account ID to the User Profile Model
userModel.UserAccountId = accountID;
// Create User Profile with the Passed on Account ID
var userProfileId = await _userProfileService.CreateUserProfile(userModel);
UserAccountSettingsModel userAccountSettingsModel = new UserAccountSettingsModel();
userAccountSettingsModel.FontSize = 12;
userAccountSettingsModel.FontStyle = "Default";
userAccountSettingsModel.ThemeColor = "Light";
userAccountSettingsModel.UserId = accountID;
await _accountSettingsService.CreateUserAccountSettingsAsync(userAccountSettingsModel);
var assignmentPolicy = await _assignmentPolicyService.GetAssignmentPolicyByRole(accountModel.AccountType, 1);
var scopes = assignmentPolicy.SuccessValue.AssignedScopes;
var userScopes = new List <UserScopeModel>();
var userClaims = new List <UserClaimModel>();
foreach (var scope in scopes)
{
var userScope = new UserScopeModel()
{
Type = scope.Type,
UserAccountId = accountID
};
userScopes.Add(userScope);
foreach (var claim in scope.Claims)
{
var repeat = false;
foreach (var userClaim in userClaims)
{
if (userClaim.Type == claim.Type)
{
repeat = true;
}
}
if (repeat)
{
continue;
}
var userClaimModel = new UserClaimModel()
{
Type = claim.Type,
Value = claim.Value,
UserAccountId = accountID
};
userClaims.Add(userClaimModel);
}
}
// Create a new claims principal
await _claimsPrincipalService.CreateClaimsPrincipal(new ClaimsPrincipal()
{
Scopes = userScopes,
Claims = userClaims,
Role = accountModel.AccountType,
UserAccountId = accountID
});
//Log and Return result
_logger.Log("User: "******" was registered", LogTarget.All, LogLevel.info, this.ToString(), "User_Logging");
resultModel.WasSuccessful = true;
resultModel.SuccessValue = accountID;
await _emailService.CreateVerificationToken(accountID);
var emailResult = await SendVerificationEmail(accountID);
//Log Email Result
if (emailResult == true)
{
_logger.Log("Verification email sent to " + accountModel.Username, LogTarget.All, LogLevel.info, this.ToString(), "User_Logging");
}
else
{
_logger.Log("Verification email failed to send to " + accountModel.Username, LogTarget.All, LogLevel.error, this.ToString(), "User_Logging");
}
return(resultModel);
}
resultModel.WasSuccessful = false;
resultModel.ErrorMessage = ErrorMessage.InvalidPassword;
Console.WriteLine("Register user failed: " + resultModel.ErrorMessage.ToString());
return(resultModel);
}
catch (SqlCustomException e)
{
Console.WriteLine("Register user failed" + e.Message);
throw new SqlCustomException(e.Message, e.InnerException);
}
catch (NullReferenceException e)
{
Console.WriteLine("Register user failed" + e.InnerException.Message);
throw new NullReferenceException(e.Message, e.InnerException);
}
}
public async Task <Messages> BatchSaveAsync(int roleId, IList <string> codes, UserClaimModel userClaim)
{
if (roleId > 0 && codes != null && codes.Count > 0)
{
using (DataTable dt = new DataTable())
{
dt.Columns.Add("r_id", typeof(int));
dt.Columns.Add("mpc_code", typeof(string));
foreach (string code in codes)
{
DataRow dr = dt.NewRow();
dr[0] = roleId;
dr[1] = code;
dt.Rows.Add(dr);
}
bool result = rmpcRepository.BatchSave(dt, roleId);
messages.Msg = result ? "更新角色权限成功！" : "更新角色权限失败";
messages.Success = result;
await logService.AddLogAsync(OperatorLogEnum.Update, string.Format("更新角色编号为：{0}权限,{1}", roleId, messages.Msg), userClaim.UserId, userClaim.UserName);
}
}
return(messages);
}
public async Task <Messages> AddByUserIdsAsync(int roleId, List <int> userIds, UserClaimModel userClaim)
{
if (roleId > 0 && userIds != null && userIds.Count > 0)
{
using (DataTable dt = new DataTable())
{
dt.Columns.Add("roleid", typeof(int));
dt.Columns.Add("userid", typeof(int));
foreach (int userid in userIds)
{
DataRow dr = dt.NewRow();
dr[0] = roleId;
dr[1] = userid;
dt.Rows.Add(dr);
}
bool result = await roleUserRepository.AddByDataTableAsync(dt);
messages.Msg = result ? "添加成功！！" : "添加失败！！";
messages.Success = result;
await logService.AddLogAsync(OperatorLogEnum.Create, string.Format("批量增加角色编号为：{0}的用户编号为{1}{2}", roleId, string.Join(",", userIds), messages.Msg), userClaim.UserId, userClaim.UserName);
}
}
return(messages);
}
public async Task <Messages> DeleteByIdsAsync(int roleId, IList <int> userIds, UserClaimModel userClaim)
{
if (roleId > 0 && userIds != null && userIds.Count > 0)
{
bool result = await roleUserRepository.DeleteByIdsAsync(roleId, userIds);
messages.Msg = result ? "删除成功！！" : "删除失败！！";
messages.Success = result;
await logService.AddLogAsync(OperatorLogEnum.Delete, string.Format("批量移除角色编号为：{0}的用户编号为{1}{2}", roleId, string.Join(",", userIds), messages.Msg), userClaim.UserId, userClaim.UserName);
}
return(messages);
}
