public HttpResponseMessage Authenticate(Dictionary <string, object> request)
{
var response = new Dictionary <string, object>();
var userName = request["USERNAME"].ToString().Trim();
var password = request["PASSWORD"].ToString();
var authType = request.ContainsKey("AUTH_TYPE") && request["AUTH_TYPE"] != null ? request["AUTH_TYPE"].ToString().ToNumber <int>() : (int)AuthType.Tin;
var deviceCode = request.ContainsKey("DEVICE_CODE") && request["DEVICE_CODE"] != null ? request["DEVICE_CODE"].ToString() : string.Empty;
var authUser = DataProviderManager <PKG_AUTHENTICATION> .Provider.authenticate(userName, password, authType, deviceCode, CommonFunctions.GetRemoteAddress, string.Empty, string.Empty);
if (authUser.IsPinCodeAuth)
{
response.Add("PIN_TOKEN", authUser.PinToken);
response.Add("MASKED_MOBILE", authUser.MaskedMobile);
}
else
{
DataProviderManager <PKG_AUTHENTICATION> .Provider.get_user_data(
authUser.SubUserID == 0?authUser.ID : authUser.SubUserID,
authUser.UserType,
authUser);
TokenManager.CreateToken(authUser);
response.Add("ACCESS_TOKEN", authUser.AccessToken);
response.Add("EXPIRES_IN", authUser.ExpiresIn);
response.Add("MASKED_MOBILE", string.Empty);
}
//response.Add("MASKED_MOBILE", currUser.MaskedMobile);
return(Success(response));
}
public string Post(string token, string newToken, string comment)
{
if (string.IsNullOrWhiteSpace(token))
{
return(ReturnMessage.ErrorMessage("token not supplied"));
}
if (!_appSettings.Value.AdminKey.Equals(token))
{
return(ReturnMessage.ErrorMessage("unauthorised access, only admin token can be used to create tokens"));
}
if (TokenManager.Tokens.Any(t => t.Key == newToken))
{
return(ReturnMessage.ErrorMessage("token alreay exists"));
}
if (string.IsNullOrWhiteSpace(newToken))
{
Token t = TokenManager.CreateToken();
return(ReturnMessage.OkTokenMessage("new token generated", t.Key));
}
else
{
TokenManager.CreateToken(newToken, comment);
return(ReturnMessage.OkTokenMessage("new token generated", newToken));
}
}
public IHttpActionResult Authenticate([FromBody] LoginViewModel vm)
{
var loginResponse = new LoginResponseViewModel {
};
LoginViewModel loginRequest = new LoginViewModel {
};
loginRequest.Username = vm.Username.ToLower();
loginRequest.Password = vm.Password;
IHttpActionResult response;
HttpResponseMessage responseMsg = new HttpResponseMessage();
bool isUserNameandPasswordValid = false;
if (vm != null)
{
isUserNameandPasswordValid = loginRequest.Password == "admin" ? true : false;
}
if (isUserNameandPasswordValid)
{
string token = TokenManager.CreateToken(loginRequest.Username);
return(Ok <string>(token));
}
else
{
loginResponse.ResponseMsg.StatusCode = HttpStatusCode.Unauthorized;
response = ResponseMessage(loginResponse.ResponseMsg);
return(response);
}
}
public async Task OAuth_Password_Test2(string apiUrl)
{
TokenManager tm = new TokenManager("pwmis", "1234567890");
var tokenResponse = await tm.CreateToken("oath2");
oAuthCenterClient.CurrentToken = tokenResponse;
//获取 access_token 后10秒内必须使用它，否则会过期，需要刷新后取得它再访问资源服务器
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokenResponse.AccessToken);
var response = await _httpClient.GetAsync(apiUrl);//"/api/values"
if (response.StatusCode != HttpStatusCode.OK)
{
Console.WriteLine(response.StatusCode);
Console.WriteLine((await response.Content.ReadAsAsync <HttpError>()).ExceptionMessage);
}
Console.WriteLine(await response.Content.ReadAsStringAsync());
//Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Console.WriteLine("10秒后测试刷新AccessToken...");
Thread.Sleep(10000);
for (int a = 0; a < 3; a++)
{
for (int i = 0; i < 5; i++)
{
Task.Factory.StartNew(obj =>
{
int index = (int)obj;
Console.WriteLine("--No.{0}----------Thread ID:{1}-", index, Thread.CurrentThread.ManagedThreadId);
var tokenResponseTwo = tm.TakeToken();
if (tokenResponseTwo != null)
{
Console.WriteLine("第{0}次刷新令牌成功。Trhead ID:{1}", index, Thread.CurrentThread.ManagedThreadId);
oAuthCenterClient.CurrentToken = tokenResponseTwo;
oAuthCenterClient.SetAuthorizationRequest(_httpClient, tokenResponseTwo);
//var responseTwo = await _httpClient.GetAsync(apiUrl);
var responseTwo = _httpClient.GetAsync(apiUrl).Result;
if (responseTwo != null)
{
Console.WriteLine("第{0}次刷新令牌，访问资源，结果：{1},Trhead ID:{2}", index, responseTwo.StatusCode, Thread.CurrentThread.ManagedThreadId);
}
else
{
Console.WriteLine("第{0}次刷新令牌，访问资源失败。。。。。", index);
}
}
else
{
Console.WriteLine("********第{0}次*获取令牌失败**************", index);
}
tm.Dispose();
}, (object)i);
}
Console.WriteLine("5 秒后进行下次测试--------------------");
Thread.Sleep(5000);
}
Console.WriteLine("测试完成.");
}
public async Task <IActionResult> Login([FromBody] Credentials model)
{
ResponseModel <LoginUserViewModel> response = new ResponseModel <LoginUserViewModel>();
try
{
response = await _accountServices.LoginAsync(model);
if (response.Status)
{
var user = response.Entity;
string tokenString = TokenManager.CreateToken(user.Id, user.FirstName, user.Email, user.Roles.RomeName);
response.Entity.Token = tokenString;
response.Entity.IsAuthenticated = true;
response.IsAuthenticated = true;
response.Token = tokenString;
return(Ok(response));
}
else
{
return(Ok(response));
}
}
catch (Exception ex)
{
response.Status = false;
response.ReturnMessage.Add(ex.Message);
return(BadRequest(response));
}
}
public IHttpActionResult LoginTest(string userName, string Password)
{
AjaxResult <string> result = new AjaxResult <string>();
if (LoginHelper.Checked(userName, Password))
{
Dictionary <string, object> payLoad = new Dictionary <string, object>();
payLoad.Add("sub", "user");
payLoad.Add("jti", Guid.NewGuid().ToString());
payLoad.Add("nbf", null);
payLoad.Add("exp", null);
payLoad.Add("iss", "Issuser");
payLoad.Add("aud", "user");
payLoad.Add("user", userName);
var token = TokenManager.CreateToken(payLoad, 30);
result.status = ResultStatus.OK;
result.msg = "登录成功";
result.Data = token;
var cookie = new HttpCookie("MRCToken");
cookie.Expires = DateTime.Now.AddDays(1);
cookie.Domain = Request.RequestUri.Host;
cookie.Path = "/";
cookie.Value = token;
CacheHelper.Set("userToken:" + userName, token.ToMD5());//应放在redis 防止重启站点丢失 或者多站点情况下 无法共享
HttpContext.Current.Response.AppendCookie(cookie);
}
else
{
result.status = ResultStatus.Failed;
result.msg = "登录失败";
}
return(Json(result));
}
public HttpResponseMessage RegisterUser(HttpRequestMessage request, [FromBody] UserInformation userInformation)
{
TransactionalInformation transaction = new TransactionalInformation();
UserBusinessService userBusinessService = new UserBusinessService(_userDataService);
User user = userBusinessService.RegisterUser(userInformation, out transaction);
if (transaction.ReturnStatus == false)
{
var badResponse = Request.CreateResponse <TransactionalInformation>(HttpStatusCode.BadRequest, transaction);
return(badResponse);
}
userInformation.UserID = user.UserID;
string tokenString = TokenManager.CreateToken(userInformation);
userInformation.UserID = user.UserID;
userInformation.ReturnStatus = true;
userInformation.ReturnMessage = transaction.ReturnMessage;
var response = Request.CreateResponse <UserInformation>(HttpStatusCode.OK, userInformation);
response.Headers.Add("Access-Control-Expose-Headers", "Authorization");
response.Headers.Add("Authorization", tokenString);
return(response);
}
public HttpResponseMessage AuthenticateTrustedUser(Dictionary <string, object> request)
{
var response = new Dictionary <string, object>();
var userId = request["USER_ID"].ToString().ToNumber <long>();
var userType = request["USER_TYPE"].ToString().ToNumber <int>();
if (AuthUser.TrustingUsers.Count(s => s.UserID == userId && s.UserType == userType) == 0)
{
ThrowError(-109);
}
if (AuthUser.MobileVerification == 0 && userType == 5)
{
ThrowError(-110);
}
var authUser = DataProviderManager <PKG_AUTHENTICATION> .Provider.authenticate_trusted_user(userId, userType, CommonFunctions.GetRemoteAddress);
DataProviderManager <PKG_AUTHENTICATION> .Provider.get_user_data(authUser.SubUserID == 0?authUser.ID : authUser.SubUserID, authUser.UserType, authUser);
TokenManager.CreateToken(authUser);
response.Add("ACCESS_TOKEN", authUser.AccessToken);
response.Add("EXPIRES_IN", authUser.ExpiresIn);
return(Success(response));
}
public IActionResult Login(HttpRequestMessage request, [FromBody] CustomerModel customerModel)
{
TransactionalBase transaction = new TransactionalBase();
string emailAddress = customerModel.EmailAddress;
string password = customerModel.Password;
CustomerBusinessService customerBusinessService = new CustomerBusinessService(_customerDataService);
Customer customer = customerBusinessService.Login(emailAddress, password, out transaction);
if (transaction.ReturnStatus == false)
{
return(new ObjectResult(transaction));
}
string tokenString = TokenManager.CreateToken(customer.Id);
customerModel.Id = customer.Id;
customerModel.EmailAddress = customer.EmailAddress;
customerModel.FirstName = customer.FirstName;
customerModel.LastName = customer.LastName;
customerModel.IsAuthenticated = true;
customerModel.Token = tokenString;
customerModel.ReturnStatus = true;
customerModel.ReturnMessage = transaction.ReturnMessage;
customerModel.Token = tokenString;
return(new ObjectResult(customerModel));
}
public async Task <ActionResult> Index(LogonModel model)
{
LogonResultModel result = new LogonResultModel();
//result.UserName="";
//首先，调用授权服务器，以密码模式获取访问令牌
//授权服务器会携带用户名和密码到认证服务器去验证用户身份
//验证服务器验证通过，授权服务器生成访问令牌给当前站点程序
//当前站点标记此用户登录成功，并将访问令牌存储在当前站点的用户会话中
//当前用户下次访问别的站点的WebAPI的时候，携带此访问令牌。
TokenManager tm = new TokenManager(model.UserName, Session.SessionID);
var tokenResponse = await tm.CreateToken(model.Password, model.ValidationCode);
if (tokenResponse != null && !string.IsNullOrEmpty(tokenResponse.AccessToken))
{
result.UserId = 123;
result.UserName = model.UserName;
result.LogonMessage = "OK";
/* OWin的方式
* ClaimsIdentity identity = new ClaimsIdentity("Basic");
* identity.AddClaim(new Claim(ClaimTypes.Name, model.UserName));
* ClaimsPrincipal principal = new ClaimsPrincipal(identity);
* HttpContext.User = principal;
*/
FormsAuthentication.SetAuthCookie(model.UserName, false);
}
else
{
result.LogonMessage = tm.TokenExctionMessage;
}
return(Json(result));
}
public HttpResponse OnRecieveRequest(HttpRequest request)
{
string tokenText = TokenManager.CreateToken(true, 800, "test");
HttpResponse response = new HttpResponse("test");
response.RedirectWithAuthorization("/private/secure.html", tokenText);
return(response);
}
public void CreateToken_ShouldReturnResultOfExpectedLength()
{
//arrange
var appSettings = Options.Create(MockAppSettings().Object);
var tokenManager = new TokenManager(appSettings, TestDateTime());
//act
var result = tokenManager.CreateToken(UserModelHelper.GetUser());
//assert
Assert.NotSame(7, result.Length);
}
public void CreateToken_ShouldReturnBearerString()
{
//arrange
var appSettings = Options.Create(MockAppSettings().Object);
var tokenManager = new TokenManager(appSettings, TestDateTime());
//act
var result = tokenManager.CreateToken(UserModelHelper.GetUser());
//assert
Assert.NotSame(-1, result.IndexOf("Bearer ", StringComparison.Ordinal));
}
public IActionResult Login([FromBody] LoginCredentialsForm credentials)
{
var user = _registrar.ValidateLogin(credentials);
if (user == null)
{
return(BadRequest("Incorect Username or Password"));
}
var response = _tokenManager.CreateToken(user);
return(Ok(response));
}
public string Login(string user, string password)
{
Authenticate auth = new Authenticate();
if (auth.Login(user, password))
{
return(TokenManager.CreateToken(user));
}
else
{
throw new Exception("Error 401 - Unauthorized");
}
}
public string GetToken([FromQuery] string username, [FromQuery] string password)
{
if (username == "validUser" && password == "validPassword")
{
return(TokenManager.CreateToken(new TokenIssuancePolicy(), new List <Claim>
{
new Claim("CustomerId", Guid.NewGuid().ToString()),
new Claim("username", "totallyValidUserBro"),
new Claim("ReportViolationEmail", "*****@*****.**"),
new EncryptedClaim("superSecretId", "whooaaaaaaaaaaaa")
}));
}
return("no-abla-Engles");
}
public IActionResult Login([FromBody] LoginCredentialsForm credentials)
{
var user = _registrar.ValidateLogin(credentials);
if (user == null)
{
return(BadRequest(new ErrorResponse("Incorect Username or Password")));
}
TokenManager tokenizer = new TokenManager();
var response = tokenizer.CreateToken(user, _settings.Value.TokenOptions);
return(Ok(response));
}
public IActionResult ValidateToken()
{
var userId = TokenManager.ExtractUserId(User.Claims);
var user = _userRepository.Get(userId);
if (user == null)
{
return(BadRequest());
}
TokenManager tokenizer = new TokenManager();
var response = tokenizer.CreateToken(user, _settings.Value.TokenOptions);
return(Ok(response));
}
public void CreateTokenValid()
{
//Arrange
DataBaseContext db = new DataBaseContext();
TokenManager tm = new TokenManager(db);
UserManager um = new UserManager(db);
TokenRepository tokenRepo = new TokenRepository(db);
User user = um.GetSSOUser(new Guid("AC9BCD38-CD7D-4475-8B71-70DF3C359463"));
//Act
string jwt = tm.CreateToken(user);
Token token = tokenRepo.GetToken(jwt, user.userID);
//Assert
Assert.IsNotNull(token);
}
public override async Task <BaseApiResult <object> > Process(object input, IServerProxyFactory serverProxyFactory)
{
var result = await serverProxyFactory.CreateProxy <IUserLogin>().Excute((UserLoginDto)input);
if (result.IsError())
{
return(new BaseApiResult <object> {
Code = result.Code, ErrMessage = result.ErrMessage, Data = result.Data
});
}
else
{
return(new BaseApiResult <object> {
Data = TokenManager.CreateToken(result.Data)
});
}
}
// GET api/WebAuth
public async Task <IHttpActionResult> Post([FromBody] LoginPoco assertion)
{
UserAccount user;
if ((user = await _authManager.IsValidAssertion(assertion)) == null)
{
return(Unauthorized());
}
var token = await _tokenManager.CreateToken(user);
return(Ok(new LoginResult
{
AuthenticationToken = token,
User = new LoginResultUser {
UserId = user.UserName
}
}));
}
public HttpResponseMessage Login(HttpRequestMessage request, [FromBody] UserInformation userInformation)
{
string errorMessage = string.Empty;
TransactionalInformation transaction = new TransactionalInformation();
string emailAddress = userInformation.EmailAddress;
string password = userInformation.Password;
UserBusinessService userBusinessService = new UserBusinessService(_userDataService);
User user = userBusinessService.Login(emailAddress, password, out transaction);
if (transaction.ReturnStatus == false)
{
var badResponse = Request.CreateResponse <TransactionalInformation>(HttpStatusCode.BadRequest, transaction);
return(badResponse);
}
userInformation.UserID = user.UserID;
string tokenString = TokenManager.CreateToken(userInformation);
userInformation.UserID = user.UserID;
userInformation.EmailAddress = user.EmailAddress;
userInformation.FirstName = user.FirstName;
userInformation.LastName = user.LastName;
userInformation.AddressLine1 = user.AddressLine1;
userInformation.AddressLine2 = user.AddressLine2;
userInformation.City = user.City;
userInformation.State = user.State;
userInformation.ZipCode = user.ZipCode;
userInformation.ReturnStatus = true;
userInformation.ReturnMessage = transaction.ReturnMessage;
var response = Request.CreateResponse <UserInformation>(HttpStatusCode.OK, userInformation);
response.Headers.Add("Access-Control-Expose-Headers", "Authorization");
response.Headers.Add("Authorization", tokenString);
return(response);
}
public HttpResponseMessage AuthenticatePrivate(Dictionary <string, object> request)
{
var response = new Dictionary <string, object>();
var userName = request["USERNAME"].ToString().Trim();
var password = request["PASSWORD"].ToString();
var clientIP = request["CLIENT_IP"].ToString();
var secretKey = request["SECRET_KEY"].ToString();
var authType = request.ContainsKey("AUTH_TYPE") && request["AUTH_TYPE"] != null ? request["AUTH_TYPE"].ToString().ToNumber <int>() : (int)AuthType.Tin;
var deviceCode = request.ContainsKey("DEVICE_CODE") && request["DEVICE_CODE"] != null ? request["DEVICE_CODE"].ToString() : string.Empty;
var latitude = request.ContainsKey("LATITUDE") && request["LATITUDE"] != null ? request["LATITUDE"].ToString() : string.Empty;
var longitude = request.ContainsKey("LONGITUDE") && request["LONGITUDE"] != null ? request["LONGITUDE"].ToString() : string.Empty;
if (secretKey != "ae0434da-1366-44f5-8798-524c5be11766")
{
ThrowError(-1);
}
var authUser = DataProviderManager <PKG_AUTHENTICATION> .Provider.authenticate(userName, password, authType, deviceCode, clientIP, latitude, longitude);
if (authUser.IsPinCodeAuth)
{
response.Add("PIN_TOKEN", authUser.PinToken);
response.Add("MASKED_MOBILE", authUser.MaskedMobile);
}
else
{
DataProviderManager <PKG_AUTHENTICATION> .Provider.get_user_data(
authUser.SubUserID == 0?authUser.ID : authUser.SubUserID,
authUser.UserType,
authUser);
TokenManager.CreateToken(authUser);
response.Add("ACCESS_TOKEN", authUser.AccessToken);
response.Add("EXPIRES_IN", authUser.ExpiresIn);
response.Add("MASKED_MOBILE", string.Empty);
}
response.Add("SECRET_WORD", authUser.SecretWord);
return(Success(response));
}
public IActionResult RegisterCustomer(HttpRequestMessage request, [FromBody] CustomerModel customerInformation)
{
TransactionalBase transaction = new TransactionalBase();
Guid customerID = new Guid();
customerInformation.IpAddress = request.GetClientIpAddress();
CustomerBusinessService userBusinessService = new CustomerBusinessService(_customerDataService);
userBusinessService.RegisterCustomer(customerInformation, out customerID, out transaction);
if (transaction.ReturnStatus == false)
{
return(new ObjectResult(transaction));
}
customerInformation.ReturnStatus = true;
customerInformation.ReturnMessage = transaction.ReturnMessage;
customerInformation.Token = TokenManager.CreateToken(customerID);
customerInformation.IsAuthenticated = true;
return(new ObjectResult(customerInformation));
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
string firstName = context.HttpContext.User.FindFirst(ClaimTypes.Name).Value;
string emailAddress = context.HttpContext.User.FindFirst(ClaimTypes.Email).Value;
string userId = context.HttpContext.User.FindFirst(ClaimTypes.PrimarySid).Value;
string roles = context.HttpContext.User.FindFirst(ClaimTypes.Role).Value;
string system = context.HttpContext.User.FindFirst(ClaimTypes.System).Value;
string token = TokenManager.CreateToken(userId, firstName, emailAddress, roles);
SecurityModel securityModel = new SecurityModel();
securityModel.EmailAddress = emailAddress;
securityModel.FirstName = firstName;
securityModel.UserId = userId;
securityModel.Roles = roles;
securityModel.System = system;
securityModel.Token = token;
context.HttpContext.Items["SecurityModel"] = securityModel;
var resultContext = await next();
}
public HttpResponseMessage Login(HttpRequestMessage request, [FromBody] UserInformation userInformation)
{
string errorMessage = string.Empty;
TransactionalInformation transaction = new TransactionalInformation();
string emailAddress = userInformation.EmailAddress;
string password = userInformation.Password;
UsuarioVista user = UsuarioBusiness.ValidaUsuario(emailAddress, password, out transaction);
if (transaction.ReturnStatus == false)
{
var badResponse = Request.CreateResponse <TransactionalInformation>(HttpStatusCode.BadRequest, transaction);
return(badResponse);
}
userInformation.UserID = user.id_persona_institucional;
string tokenString = TokenManager.CreateToken(userInformation);
userInformation.UserID = user.id_persona_institucional;
userInformation.EmailAddress = user.Mail;
userInformation.FirstName = user.Nombre;
userInformation.LastName = user.Apellido;
userInformation.AddressLine1 = user.Domicilio;
//userInformation.AddressLine2 = user.AddressLine2;
//userInformation.City = user.;
//userInformation.State = user.State;
//userInformation.ZipCode = user.ZipCode;
userInformation.ReturnStatus = true;
userInformation.ReturnMessage = transaction.ReturnMessage;
var response = Request.CreateResponse <UserInformation>(HttpStatusCode.OK, userInformation);
response.Headers.Add("Access-Control-Expose-Headers", "Authorization");
response.Headers.Add("Authorization", tokenString);
return(response);
}
public object Post([FromBody] LoginObj loginObj)
{
if (loginObj.UserName == "John" && loginObj.Password == "password")
{
TokenManager tokenManager = new TokenManager();
string token = tokenManager.CreateToken(new User()
{
Name = loginObj.UserName, Privilege = "user"
});
return(new
{
jwtToken = token,
message = "Authentication successful."
});
}
else
{
return(new
{
message = "Authentication failed."
});
}
}
public async Task Token(LoginViewModel loginViewModel)
{
TokenManager tokenManager = new TokenManager(_users);
ClaimsIdentity identity = null;
User user = _users.GetAll().Where(u => u.Login.Equals(loginViewModel.Login) || u.Email.Equals(loginViewModel.Login)).FirstOrDefault();
if (user != null)
{
identity = tokenManager.GetIdentity(user.Login, loginViewModel.Password);
}
if (identity == null)
{
Logger.Logger.LogError("IdentityController:Token():Invalid username or password.");
Response.StatusCode = 400;
await Response.WriteAsync("Invalid username or password.");
return;
}
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(tokenManager.CreateToken(identity));
var response = new
{
access_token = encodedJwt,
expires = AuthOptions.LIFETIME,
status = StatusCode(200).StatusCode
};
Logger.Logger.LogInfo($"IdentityController:Token():User {loginViewModel.Login} signed in.");
Response.ContentType = "application/json";
await Response.WriteAsync(JsonConvert.SerializeObject(response, new JsonSerializerSettings {
Formatting = Formatting.Indented
}));
}
public HttpResponseMessage AuthenticatePin(Dictionary <string, object> request)
{
var response = new Dictionary <string, object>();
var pinToken = request["PIN_TOKEN"].ToString();
var mobileCode = request["PIN"].ToString();
var deviceInfo = new DeviceInfo
{
device_code = request.ContainsKey("DEVICE_CODE") && request["DEVICE_CODE"] != null ? request["DEVICE_CODE"].ToString() : string.Empty,
address = request.ContainsKey("ADDRESS") && request["ADDRESS"] != null ? request["ADDRESS"].ToString() : string.Empty,
browser = request.ContainsKey("BROWSER") && request["BROWSER"] != null ? request["BROWSER"].ToString() : string.Empty,
oper_system = request.ContainsKey("OPER_SYSTEM") && request["OPER_SYSTEM"] != null ? request["OPER_SYSTEM"].ToString() : string.Empty
};
var authUser = DataProviderManager <PKG_AUTHENTICATION> .Provider.authenticate_pin(pinToken, mobileCode);
if (authUser != null)
{
if (!string.IsNullOrEmpty(deviceInfo.device_code))
{
DataProviderManager <PKG_AUTHENTICATION> .Provider.save_device_code(authUser.ID, authUser.SubUserID, deviceInfo);
}
DataProviderManager <PKG_AUTHENTICATION> .Provider.get_user_data(
authUser.SubUserID == 0?authUser.ID : authUser.SubUserID,
authUser.UserType,
authUser);
authUser.PinToken = pinToken;
TokenManager.CreateToken(authUser);
response.Add("ACCESS_TOKEN", authUser.AccessToken);
response.Add("EXPIRES_IN", authUser.ExpiresIn);
}
return(Success(response));
}
public LoginModel AuthenticateUser(LoginModel model)
{
byte[] data = Convert.FromBase64String(model.Password);
string decodedPass = Encoding.UTF8.GetString(data);
UserModel user = null;
try
{
user = Login.AuthenticateUser(model.Username, decodedPass);
}
catch (Exception ex)
{
throw new HttpResponseException(
new HttpResponseMessage()
{
StatusCode = HttpStatusCode.Forbidden,
ReasonPhrase = ex.Message
});
}
if (user == null)
{
model.IsAuthenticated = false;
}
else
{
List <ClaimModel> claims = new List <ClaimModel>();
model.IsAuthenticated = true;
model.UserID = user.UserID;
claims.Add(new ClaimModel()
{
Name = "UserID", Value = user.UserID.ToString()
});
// get user details
model.Username = user.Username;
claims.Add(new ClaimModel()
{
Name = "Username", Value = user.Username
});
model.FirstName = user.FirstName;
model.LastName = user.LastName;
model.FullName = user.FullName;
claims.Add(new ClaimModel()
{
Name = "UserFullName", Value = user.FullName
});
// do not send user password back to font-end
model.Password = string.Empty;
// get user groups
// List<UserGroupModel> userGroups = UserGroups.GetUserGroupsByUser(user.UserID);
List <UserGroupModel> userGroups = user.UserGroups;
model.UserGroups = userGroups.Select(ug => ug.UserGroupName).ToList();
claims.Add(new ClaimModel()
{
Name = "UserGroups", Value = JsonConvert.SerializeObject(model.UserGroups)
});
// get effective permissions
model.EffectivePermissions = Users.GetEffectivePermissions(user.UserID);
claims.Add(new ClaimModel()
{
Name = "EffectivePermissions", Value = JsonConvert.SerializeObject(model.EffectivePermissions)
});
// get dance groups (with payment ability info)
model.UserDanceGroups = Users.GetUserDanceGroups(user.UserID);
claims.Add(new ClaimModel()
{
Name = "UserDanceGroups", Value = JsonConvert.SerializeObject(model.UserDanceGroups)
});
// create token
model.Token = TokenManager.CreateToken(claims);
}
return(model);
}
