public async Task<ClaimsIdentity> Authenticate(AuthUser authUser)
{
ClaimsIdentity claims = null;
//find User
User user = await _dataBase.UserManager.FindAsync(authUser.Email, authUser.Password);
if(user != null)
{
claims = await _dataBase.UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
}
return claims;
}
public async Task<OperationDetails> Create(AuthUser authUser)
{
User user = await _dataBase.UserManager.FindByEmailAsync(authUser.Email);
if(user == null)
{
user = new User() { Email = authUser.Email, UserName = authUser.UserName };
await _dataBase.UserManager.CreateAsync(user, authUser.Password);
//add Role
_dataBase.Save();
return new OperationDetails(true, "Пользователь создан. Операция произошла успешно.", "Email");
}
else
{
return new OperationDetails(false, "Пользователь с такой почтой уже существует.", "Email");
}
}
public IHttpActionResult Post([FromBody] AuthUser users)
{
try
{
//var scheme = Request.Headers.Authorization.Scheme;
//var token = Request.Headers.Authorization.Parameter;
var result = JwtManager.ValidateToken(Request);
if (result)
{
return(Ok(result));
}
else
{
return(new HttpActionResult(HttpStatusCode.BadRequest, "Invalidate Json Web Token")); // can use any HTTP status code
}
}
catch (Exception)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "Invalidate Json Web Token")));
}
}
private string GenerateJwtToken(string email, AuthUser user)
{
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString())
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["JwtKey"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expires = DateTime.Now.AddDays(Convert.ToDouble(Configuration["JwtExpireDays"]));
var token = new JwtSecurityToken(
Configuration["JwtIssuer"],
Configuration["JwtIssuer"],
claims,
expires: expires,
signingCredentials: creds
);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
public bool UpdateThreadCateModelFields(AuthUser operatorUser, IEnumerable <int> fieldIDs, IEnumerable <bool> enables, IEnumerable <int> sortOrders
, IEnumerable <bool> searchs, IEnumerable <bool> advancedSearchs, IEnumerable <bool> displayInLists, IEnumerable <bool> mustFilleds)
{
if (AllSettings.Current.BackendPermissions.Can(operatorUser, BackendPermissions.Action.Manage_ThreadCate) == false)
{
ThrowError(new NoPermissionManageThreadCateError());
return(false);
}
if (ValidateUtil.HasItems <int>(fieldIDs) == false)
{
return(true);
}
bool success = ThreadCateDao.Instance.UpdateThreadCateModelFields(fieldIDs, enables, sortOrders, searchs, advancedSearchs, displayInLists, mustFilleds);
if (success)
{
allThreadCateModelFields = null;
}
return(success);
}
public DataSet GetUserObject(AuthUser objAuthUser)
{
DbParam[] param = new DbParam[]
{
new DbParam(objAuthUser.MobileNo, typeof(System.String), "_mobile"),
new DbParam(objAuthUser.Password, typeof(System.String), "_password"),
new DbParam(objAuthUser.SchoolTenentId, typeof(System.String), "_schooltenentId"),
new DbParam(objAuthUser.IsFaculty, typeof(System.Boolean), "_isFaculty")
};
DataSet ds = db.GetDataset("sp_MobileUserMaster_Detail", param);
if (ds != null && ds.Tables.Count == 3)
{
ds.Tables[0].TableName = "LoginUser";
ds.Tables[1].TableName = "Student";
ds.Tables[2].TableName = "Notification";
}
else
{
ds = null;
}
return(ds);
}
public async Task <IActionResult> Register(Login login)
{
if (_context.AppUsers.Any(u => u.Username == login.Username))
{
return(BadRequest("User Already Exists"));
}
var user = new AuthUser();
user.UserName = login.Username;
user.AppUser = new Data.User()
{
Username = login.Username
};
var result = await _userManager.CreateAsync(user, login.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors.FirstOrDefault()?.Description));
}
return(await Login(login));
}
public async Task <IActionResult> LogIn(AuthUser authUser, string returnUrl)
{
if (ModelState.IsValid)
{
var userName = new MailAddress(authUser.UserEmail).User;
var userSignInResult = await _signInManager.PasswordSignInAsync(userName, authUser.UserPassword, true, false);
if (userSignInResult.Succeeded)
{
var userRole = _getCurrentlyLoggedInUserRole(userName);
if (userRole == "Teacher")
{
return(RedirectToAction("__init__", "Teachers",
new { tid = _getCurrentlyLoggedInUserId(userName) }));
}
return(RedirectToAction("__init__", "Students",
new { sid = _getCurrentlyLoggedInUserId(userName) }));
}
ModelState.AddModelError("", "Invalid SignIn Attempt");
}
return(View(authUser));
}
private void SendToClient(ReportArgs args, int status = 0)
{
string token = TwinkleContext.UserToken;
AuthUser user = TwinkleContext.GetService <TokenAuthManager>().GetUser(token);
IRealTimeNotifier rtf = TwinkleContext.GetService <IRealTimeNotifier>();
rtf.SendNotificationsAsync(new UserNotification[] {
new UserNotification {
TenantId = user.TenantId,
UserId = user.UserId,
Data = new NotifyData {
Channel = "signalr.reveive",
Data = new {
uploadId = TwinkleContext.HttpContext.Request.Form["uploadId"].ToString(),//有待测试验证
message = args.Message,
status = args.Status
}
}
}
});
}
/// <summary>
/// JWT erzeugen. Minimale Claim-Infos: Email und Rolle
/// </summary>
/// <param name="userInfo"></param>
/// <returns>Token mit Claims</returns>
private string GenerateJwtToken(AuthUser userInfo)
{
var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Jwt:SecretKey"]));
var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
var authClaims = new List <Claim>();
authClaims.Add(new Claim(ClaimTypes.Email, userInfo.Email));
authClaims.Add(new Claim(ClaimTypes.Country, "Austria"));
if (!string.IsNullOrEmpty(userInfo.UserRole))
{
authClaims.Add(new Claim(ClaimTypes.Role, userInfo.UserRole));
}
var token = new JwtSecurityToken(
issuer: _config["Jwt:Issuer"],
audience: _config["Jwt:Audience"],
claims: authClaims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: credentials);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
public async Task <ManageInfoViewModel> GetManageInfo(string returnUrl, bool generateState = false)
{
AuthUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user == null)
{
return(null);
}
List <UserLoginInfoViewModel> logins = new List <UserLoginInfoViewModel>();
//foreach (IdentityUserLogin linkedAccount in user.Logins)
//{
// logins.Add(new UserLoginInfoViewModel
// {
// LoginProvider = linkedAccount.LoginProvider,
// ProviderKey = linkedAccount.ProviderKey
// });
//}
//if (user.PasswordHash != null)
//{
// logins.Add(new UserLoginInfoViewModel
// {
// LoginProvider = LocalLoginProvider,
// ProviderKey = user.UserName,
// });
//}
return(new ManageInfoViewModel
{
LocalLoginProvider = LocalLoginProvider,
UserName = user.UserName,
Logins = logins,
ExternalLoginProviders = GetExternalLogins(returnUrl, generateState)
});
}
public (DataSet, string) GetLoginUserObject(AuthUser authUser)
{
string Token = null;
string ProcessingData = null;
DbParam[] param = new DbParam[]
{
new DbParam(authUser.UserId, typeof(System.String), "_mobile"),
new DbParam(authUser.Password, typeof(System.String), "_password")
};
DataSet ds = db.GetDataset("sp_GetLoginUser_Detail", param, true, ref ProcessingData);
if (ds != null && ds.Tables.Count > 0)
{
this.autoMapper = new TableAutoMapper();
UserDetail userDetail = this.autoMapper.AutoMapToObject <UserDetail>(ds.Tables[0]);
if (userDetail != null)
{
authUser.Role = Policies.Admin;
Token = GenerateToken(authUser);
beanContext.AddNewSession(string.Empty, "userdetail", userDetail, Token);
}
}
if (ds.Tables.Count == 8)
{
ds.Tables[0].TableName = "CurrentUser";
ds.Tables[1].TableName = "Classes";
ds.Tables[2].TableName = "TotalCount";
ds.Tables[3].TableName = "Menu";
ds.Tables[4].TableName = "Subject";
ds.Tables[5].TableName = "Roles";
ds.Tables[6].TableName = "ColumnMapping";
ds.Tables[7].TableName = "StateNCity";
}
return(ds, Token);
}
public static void Login(string login)
{
// Bring user from database
var user = UserService.GetLoginInfo(login);
// Create serializable user
var serializeModel = new SerializablePrincipal
{
Login = user.Login,
CorpHoCode = user.CorpHoCode,
CorpBrandCode = user.CorpBrandCode,
};
var timeout = Config.Security.UserSessionTimeout;
// Serialize for the cookie
var userData = JsonConvert.SerializeObject(serializeModel);
var authTicket = new FormsAuthenticationTicket(1, user.Login, DateTime.Now, DateTime.Now.AddMinutes(timeout), false, userData);
string encryptedTicket = FormsAuthentication.Encrypt(authTicket);
var faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
// Set cookie
HttpContext.Current.Response.Cookies.Add(faCookie);
// Add user for this request
var authUser = new AuthUser(user.Login)
{
Login = user.Login
};
// Set our auth user as the current user on the context
HttpContext.Current.User = authUser;
// Load info from database and cache
LoadUserInfo(login);
LoadUserPermissions();
}
private static void AuthorizationMethod()
{
bool shouldClose = false;
try
{
var authorization = new AuthUser();
ServerPackage package = null;
package = authorization.ValidateUser();
if (package == null)
{
return;
}
if (package.validationResult == ValidationResult.expired)
{
splashThread.Abort();
Application.Run(new PaymentWindow(package));
}
else if (package.validationResult == ValidationResult.actual)
{
splashThread.Abort();
Application.Run(new MainWindow(package));
}
else //temporary
{
splashThread.Abort();
Application.Run(new MainWindow(package));
}
}
catch (Exception error)
{
//Log.Error(error);
//HandleError.CloseProgram();
}
}
public async Task <AuthResponse> Login(LoginRequestModel model)
{
AuthUser user = await this.userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse("Invalid email or password", AuthErrorCodes.InvalidUsernameOrPassword));
}
else
{
if (this.userManager.PasswordHasher.VerifyHashedPassword(user, user.PasswordHash, model.Password) == PasswordVerificationResult.Success)
{
IList <Claim> claims = await this.userManager.GetClaimsAsync(user);
IList <string> roles = await this.userManager.GetRolesAsync(user);
foreach (string role in roles)
{
claims.Add(new Claim(ClaimTypes.Role, role));
}
string token = this.jwtService.GenerateBearerToken(
this.apiSettings.JwtSettings.SigningKey,
this.apiSettings.JwtSettings.Audience,
this.apiSettings.JwtSettings.Issuer,
user.Id,
user.Email,
claims);
return(ValidationResponseFactory <AuthResponse> .SuccessAuthResponseWithToken(token));
}
else
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse("Invalid email or password", AuthErrorCodes.InvalidUsernameOrPassword));
}
}
}
public async Task <ActionResult> AuthUser([FromBody] AuthUser authUser)
{
TabUser user = await _userService.authUser(authUser);
if (user == null)
{
return(BadRequest("Senha ou email inválidos!"));
}
var claims = new[]
{
new Claim("id", user.UserId.ToString()),
new Claim("userName", user.UserName),
new Claim("fullName", user.UserFullName),
new Claim("email", user.UserEmail)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["SecurityKey"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: "Code Cave Web Solution",
audience: user.UserEmail,
claims: claims,
expires: DateTime.Now.AddMinutes(1),
signingCredentials: creds
);
Response.Headers.Add("x-access-token", new JwtSecurityTokenHandler().WriteToken(token));
return(Ok());
//return Ok(new
//{
// token = new JwtSecurityTokenHandler().WriteToken(token)
//});
}
private async Task SeedAdminUsers()
{
var user = new AuthUser
{
UserName = "******",
NormalizedUserName = "******",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
EmailConfirmed = true,
LockoutEnabled = false,
SecurityStamp = Guid.NewGuid().ToString()
};
var roleStore = new RoleStore <AuthRole>(_tmContext);
if (!_tmContext.Roles.Any(r => r.Name == RoleName.CanManageSite))
{
await roleStore.CreateAsync(new AuthRole { Name = RoleName.CanManageSite, NormalizedName = RoleName.CanManageSite, Description = "Site Administrator" });
}
if (!_tmContext.Roles.Any(r => r.Name == RoleName.CanManageInvoices))
{
await roleStore.CreateAsync(new AuthRole { Name = RoleName.CanManageInvoices, NormalizedName = RoleName.CanManageInvoices, Description = "Can Manage Invoices" });
}
if (!_tmContext.Users.Any(u => u.UserName == user.UserName))
{
var password = new PasswordHasher <AuthUser>();
var hashed = password.HashPassword(user, "balda1234");
user.PasswordHash = hashed;
await _userManager.CreateAsync(user);
await _userManager.AddToRoleAsync(user, RoleName.CanManageSite);
}
await _tmContext.SaveChangesAsync();
}
public ObservationSaveFinal SaveF(AuthUser authUser, ObservationSaveFinal observation)
{
var paramsList = new List <SqlParameter>
{
new SqlParameter("@CODAVALIACAO", observation.CodAvaliacao),
new SqlParameter("@CHAPAAVALIADOR", observation.ChapaAvaliador),
new SqlParameter("@CHAPAAVALIADO", observation.ChapaAvaliado),
new SqlParameter("@A1", observation.A1 != null ? int.Parse(observation.A1) : -1),
new SqlParameter("@B2", observation.B2 != null ? int.Parse(observation.B2) : -1),
new SqlParameter("@C3", observation.C3 != null ? int.Parse(observation.C3) : -1),
new SqlParameter("@D4", observation.D4 != null ? int.Parse(observation.D4) : -1),
new SqlParameter("@E5", observation.E5 != null ? int.Parse(observation.E5) : -1),
new SqlParameter("@F6", observation.F6 != null ? int.Parse(observation.F6) : -1),
new SqlParameter("@G1", observation.G1 != null ? int.Parse(observation.G1) : -1),
new SqlParameter("@G2", observation.G2 != null ? int.Parse(observation.G2) : -1),
new SqlParameter("@G3", observation.G3 != null ? int.Parse(observation.G3) : -1),
new SqlParameter("@G41", observation.G41 != null ? int.Parse(observation.G41) : -1),
new SqlParameter("@G42", observation.G42 != null ? int.Parse(observation.G42) : -1),
new SqlParameter("@G5", observation.G5 != null ? int.Parse(observation.G5) : -1),
new SqlParameter("@G6", observation.G6 != null ? int.Parse(observation.G6) : -1),
new SqlParameter("@G7", observation.G7 != null ? int.Parse(observation.G7) : -1),
new SqlParameter("@H1", observation.H1 != null ? observation.H1 : ""),
new SqlParameter("@H2", observation.H2 != null ? observation.H2 : ""),
new SqlParameter("@H3", observation.H3 != null ? observation.H3 : ""),
new SqlParameter("@H4", observation.H4 != null ? observation.H4 : ""),
new SqlParameter("@H5", observation.H5 != null ? observation.H5 : ""),
new SqlParameter("@H6", observation.H6 != null ? observation.H6 : ""),
new SqlParameter("@H7", observation.H7 != null ? observation.H7 : ""),
new SqlParameter("@H8", observation.H8 != null ? observation.H8 : ""),
new SqlParameter("@Z1", observation.Z1 != null ? observation.Z1 : "")
};
SqlParameter[] parameters = paramsList.ToArray();
Db.Database.ExecuteSqlCommand("EXECUTE [dbo].[SPU_OBSERVATION_FINAL_SAVE] @CODAVALIACAO,@CHAPAAVALIADOR,@CHAPAAVALIADO,@A1,@B2,@C3,@D4,@E5,@F6,@G1,@G2,@G3,@G41,@G42,@G5,@G6,@G7,@H1,@H2,@H3,@H4,@H5,@H6,@H7,@H8,@Z1", parameters);
return(observation);
}
public static void IgnoreNotify(int userID, int notifyID)
{
SystemNotify notify = null;
notifyID = Math.Abs(notifyID);
foreach (SystemNotify sn in CurrentSystemNotifys)
{
if (sn.NotifyID == notifyID)
{
notify = sn;
break;
}
}
if (notify != null)
{
string s = notify.ReadUserIDs;
if (string.IsNullOrEmpty(s))
{
s = string.Empty;
}
if (!s.StartsWith(","))
{
s = "," + s;
}
AuthUser user = UserBO.Instance.GetUserFromCache <AuthUser>(userID);
if (user != null)
{
user.SystemNotifyVersion = DateTimeUtil.Now.Ticks;//刷新用户的系统通知列表
s += user.UserID + ",";
}
notify.ReadUserIDs = s;
NotifyDao.Instance.SetSystemNotifyReadUserIDs(notify.NotifyID, s);
}
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
var userManager = context.OwinContext.GetUserManager <ApplicationUserManager>();
AuthUser user = await userManager.FindAsync(context.UserName, context.Password);
if (user == null)
{
context.SetError("invalid_grant", "The user name or password is incorrect.");
return;
}
ClaimsIdentity oAuthIdentity = await user.GenerateUserIdentityAsync(userManager,
OAuthDefaults.AuthenticationType);
ClaimsIdentity cookiesIdentity = await user.GenerateUserIdentityAsync(userManager,
CookieAuthenticationDefaults.AuthenticationType);
AuthenticationProperties properties = CreateProperties(user.UserName);
AuthenticationTicket ticket = new AuthenticationTicket(oAuthIdentity, properties);
context.Validated(ticket);
context.Request.Context.Authentication.SignIn(cookiesIdentity);
}
internal static WebsiteLoginResponseModel VerifyLogin(AuthUser authUser)
{
try
{
var request = (HttpWebRequest)WebRequest.Create(new Uri(String.Format(Constants.CustomerEndpoints.VerifyUserEndpoint, Constants.KitsuneServerUrl)));
request.Method = "POST";
request.ContentType = "application/json";
using (var streamWriter = new StreamWriter(request.GetRequestStream()))
{
string jsonData = JsonConvert.SerializeObject(authUser);
streamWriter.Write(jsonData);
}
var httpResponse = (HttpWebResponse)request.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
return(JsonConvert.DeserializeObject <WebsiteLoginResponseModel>(streamReader.ReadToEnd()));
}
}
catch (Exception ex)
{
throw ex;
}
}
protected override AuthUser GetUserInfo(AuthToken authToken)
{
string userinfoUrl = UserInfoUrl(authToken);
var response = HttpUtils.RequestGet(userinfoUrl);
var responseObj = response.ParseObject();
this.checkResponse(responseObj);
var userObj = responseObj.GetString("data").ParseObject();
var authUser = new AuthUser();
authUser.Uuid = userObj.GetString("id");
authUser.Username = userObj.GetString("username");
authUser.Nickname = userObj.GetString("first_name") + userObj.GetString("last_name");
authUser.Avatar = getAvatarUrl(userObj);
authUser.Remark = userObj.GetString("bio");
authUser.Gender = AuthUserGender.Unknown;
authUser.Token = authToken;
authUser.Source = source.GetName();
authUser.OriginalUser = responseObj;
authUser.OriginalUserStr = response;
return(authUser);
}
protected override AuthUser getUserInfo(AuthToken authToken)
{
string openId = this.getOpenId(authToken);
string response = doGetUserInfo(authToken);
var userObj = response.parseObject();
if (userObj.getInt32("ret") != 0)
{
throw new Exception(userObj.getString("msg"));
}
string avatar = userObj.getString("figureurl_qq_2");
if (avatar.IsNullOrWhiteSpace())
{
avatar = userObj.getString("figureurl_qq_1");
}
string location = $"{userObj.getString("province")}-{userObj.getString("city")}";
var authUser = new AuthUser();
authUser.uuid = openId;
authUser.username = userObj.getString("nickname");
authUser.nickname = userObj.getString("nickname");
authUser.avatar = avatar;
authUser.location = location;
authUser.email = userObj.getString("email");
authUser.remark = userObj.getString("bio");
authUser.gender = GlobalAuthUtil.getRealGender(userObj.getString("gender"));
authUser.token = authToken;
authUser.source = source.getName();
authUser.originalUser = userObj;
authUser.originalUserStr = response;
return(authUser);
}
protected override AuthUser getUserInfo(AuthToken authToken)
{
string userinfoUrl = userInfoUrl(authToken);
var response = HttpUtils.RequestGet(userinfoUrl);
var responseObj = response.parseObject();
this.checkResponse(responseObj);
var userObj = responseObj.getString("data").parseObject();
var authUser = new AuthUser();
authUser.uuid = userObj.getString("id");
authUser.username = userObj.getString("username");
authUser.nickname = userObj.getString("first_name") + userObj.getString("last_name");
authUser.avatar = getAvatarUrl(userObj);
authUser.remark = userObj.getString("bio");
authUser.gender = AuthUserGender.UNKNOWN;
authUser.token = authToken;
authUser.source = source.getName();
authUser.originalUser = responseObj;
authUser.originalUserStr = response;
return(authUser);
}
public override bool BeforeExecute(int operatorUserID, string param, ref long offset, ref int totalCount, out string title)
{
StringList paramData = StringList.Parse(param);
TopicFilter filter = TopicFilter.Parse(paramData[0]);
//List<Thread> threads = PostBO.Instance.GetThreads(operatorUserID, filter, 1, out tempTotalCount);
AuthUser operatorUser = UserBO.Instance.GetAuthUser(operatorUserID);
ThreadCollectionV5 threads = PostBOV5.Instance.GetThreads(operatorUser, filter, 1);
if (threads == null || threads.Count == 0)
{
title = "没有数据可以删除";
return(false);
}
totalCount = threads.TotalRecords;
title = "将删除 " + totalCount + " 个主题";
return(true);
}
public bool CreateForum(AuthUser operatorUser, string codeName, string forumName, int parentID, ForumType forumType, string password, string logoSrc
, string themeID, string readme, string description, ThreadCatalogStatus threadCatalogStaus, int columnSpan, int sortOrder
, ForumExtendedAttribute forumExtendedDatas, out int forumID)
{
forumID = 0;
if (!AllSettings.Current.BackendPermissions.Can(operatorUser, BackendPermissions.Action.Manage_Forum))
{
ThrowError <NoPermissionManageForumError>(new NoPermissionManageForumError(0));
return(false);
}
if (false == ValidateForumParams(codeName, forumName, parentID, forumType, password, logoSrc, themeID))
{
return(false);
}
int result = ForumDaoV5.Instance.CreateForum(codeName, forumName, parentID, forumType, password, logoSrc, themeID, readme, description, threadCatalogStaus, columnSpan, sortOrder, forumExtendedDatas, out forumID);
switch (result)
{
case 13:
ThrowError <DuplicateForumCodeNameError>(new DuplicateForumCodeNameError("codename", codeName));
return(false);
case -1:
ThrowError <ParentForumNotExistsError>(new ParentForumNotExistsError("parentID"));
return(false);
default: break;
}
ClearAllCache();
ThreadCachePool.ClearAllCache();
return(true);
}
/// <summary>
/// 添加版主
/// </summary>
/// <param name="operatorUserID"></param>
/// <param name="userID"></param>
/// <param name="forumIds"></param>
/// <param name="modetatorsType"></param>
public void AddModerators(AuthUser operatorUser, ModeratorCollection moderators)
{
//AuthUser user = UserBO.Instance.GetUser(operatorUserID);
//if (user == null)
// return;
if (!AllSettings.Current.BackendPermissions.Can(operatorUser, BackendPermissions.Action.Manage_Moderator))
{
ThrowError <NoPermissionManageModerator>(new NoPermissionManageModerator());
return;
}
foreach (Moderator m in moderators)
{
if (m.IsNew)
{
m.AppointorID = operatorUser.UserID;
m.IsNew = false;
}
}
if (moderators.Count == 0)
{
return;
}
if (ForumDaoV5.Instance.AddModerators(moderators))
{
this.ClearModeratorCache();
//User operatorUser = UserBO.Instance.GetUser(operatorUserID);
foreach (Moderator m in moderators)
{
Logs.LogManager.LogOperation(new Logs.ModeratorAppoint(operatorUser.UserID, operatorUser.Username, m.UserID, m.User.Username, m.ForumID, m.Name, IPUtil.GetCurrentIP()));
}
}
}
private async Task <string> RegisterIfNotAlready(GoogleUserInfoModel model)
{
var user = await _db.Users.SingleOrDefaultAsync(x => x.Email.ToLower() == model.Email.ToLower());
if (user is object)
{
return(user.Id);
}
var newUser = new AuthUser
{
Id = Guid.NewGuid().ToString(),
Email = model.Email,
UserName = model.Email,
EmailConfirmed = model.IsEmailVerified,
Name = model.Name,
PictureUrl = model.PictureUrl
};
_db.Users.Add(newUser);
await _db.SaveChangesAsync();
return(newUser.Id);
}
protected override AuthUser getUserInfo(AuthToken authToken)
{
string accessToken = authToken.accessToken;
AlipayUserInfoShareRequest request = new AlipayUserInfoShareRequest();
AlipayUserInfoShareResponse response = null;
try
{
response = this.aopClient.Execute(request, accessToken);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
if (response.IsError)
{
throw new Exception(response.SubMsg);
}
string province = response.Province, city = response.City;
string location = string.Format("{0} {1}", !province.IsNullOrWhiteSpace() ? "" : province, !city.IsNullOrWhiteSpace() ? "" : city);
var authUser = new AuthUser();
authUser.username = response.UserName.IsNullOrWhiteSpace() ? response.NickName : response.UserName;
authUser.nickname = response.NickName;
authUser.avatar = response.Avatar;
authUser.location = location;
authUser.uuid = response.UserId;
authUser.gender = GlobalAuthUtil.getRealGender(response.Gender);
authUser.token = authToken;
authUser.source = source.getName();
authUser.originalUser = response;
authUser.originalUserStr = JsonConvert.SerializeObject(response);
return(authUser);
}
public async Task NotInvokeIRegisterParserUserViewModelFactory_CreateRegisterParserUserViewModelOnceWithCorrectParameter_IfResultSucceededIsFalse()
{
// Arrange
var identityAuthAccountService = new Mock <IIdentityAuthAccountService>();
var registerParserUserViewModelFactory = new Mock <IRegisterParserUserViewModelFactory>();
var createParserUserService = new Mock <ICreateParserUserService>();
var extendedIdentityAuthAccountService = new ExtendedIdentityAuthAccountService(identityAuthAccountService.Object, registerParserUserViewModelFactory.Object, createParserUserService.Object);
var user = new AuthUser();
user.UserName = "******";
var password = "******";
var identityResult = new MockIdentityResult(false);
identityAuthAccountService.Setup(s => s.CreateAsync(It.IsAny <AuthUser>(), It.IsAny <string>())).Returns(Task.Run <IdentityResult>(() => identityResult));
// Act
await extendedIdentityAuthAccountService.CreateAsync(user, password);
// Assert
registerParserUserViewModelFactory.Verify(f => f.CreateRegisterParserUserViewModel(user.UserName), Times.Never);
}
public bool CreateImpression(AuthUser operatorUser, User targetUser, string text)
{
if (operatorUser == null || Permission.Can(operatorUser, SpacePermissionSet.Action.UseImpression) == false)
{
return(false);
}
if (targetUser == null || Permission.Can(targetUser, SpacePermissionSet.Action.UseImpression) == false)
{
return(false);
}
if (text == null)
{
ThrowError(new ImpressionTextEmptyError("text"));
return(false);
}
text = text.Trim();
if (ValidateText(text) == false)
{
return(false);
}
bool succeed = ImpressionDao.Instance.CreateImpression(operatorUser.UserID, targetUser.UserID, text, AllSettings.Current.ImpressionSettings.TimeLimit);
if (succeed)
{
Notify notify = new ImpressionNotify(operatorUser.UserID, targetUser.UserID);
NotifyBO.Instance.AddNotify(operatorUser, notify);
RemoveCachedTargetUserImpressionRecordsTotalCount(targetUser.UserID);
}
return(succeed);
}
public static string ParseForEdit(AuthUser operatorUser, int userID)
{
User user = UserBO.Instance.GetUser(userID);
if (string.IsNullOrEmpty(user.Signature))
{
return(string.Empty);
}
switch (UserBO.Instance.GetSignatureFormat(operatorUser))
{
case SignatureFormat.Html:
return(user.Signature);
case SignatureFormat.Ubb:
return(HtmlToUbbParser.Html2Ubb(userID, user.Signature));
case SignatureFormat.Text:
return(StringUtil.ClearAngleBracket(user.Signature));
default:
return(string.Empty);
}
}
