public async Task Update(LoginTokenModel loginToken)
{
using (DynamoDbContext dbContext = new DynamoDbContext())
{
await dbContext.SaveAsync <LoginTokenModel>(loginToken);
}
}
//public static long UserId
//{
// get
// {
// var cacheModel = AuthenticateToken();
// if (cacheModel != null)
// return cacheModel.UserId;
// return 0;
// }
//}
public static LoginTokenModel AuthenticateToken()
{
ObjectCache cache = MemoryCache.Default;
if (!string.IsNullOrEmpty(Token))
{
if (cache.Contains(Token))
{
LoginTokenModel tokenvalue = (LoginTokenModel)cache.Get(Token);
//Code For Making Cache Extended.
CacheItem item = cache.GetCacheItem(Token);
CacheItemPolicy cacheItemPolicy = new CacheItemPolicy();
cacheItemPolicy.AbsoluteExpiration = DateTime.Now.AddMinutes(ConfigSettings.CacheExpiryPeriod);
cache.Set(item, cacheItemPolicy);
return(tokenvalue);
}
else
{
ITokenDataProvider _securityDataProvider = new TokenDataProvider();
ServiceResponse response = _securityDataProvider.AuthenticateToken(Token);
if (response.IsSuccess)
{
LoginTokenModel tokenvalue = (LoginTokenModel)response.Data;
CacheItemPolicy cacheItemPolicy = new CacheItemPolicy();
cacheItemPolicy.AbsoluteExpiration = DateTime.Now.AddMinutes(ConfigSettings.CacheExpiryPeriod);
cache.Add(Token, tokenvalue, cacheItemPolicy);
return(tokenvalue);
}
}
}
Common.ThrowErrorMessage("Invalid token or token expired.", HttpStatusCode.Unauthorized);
return(null);
}
public ActionResult Login(string loginname, string loginpwd)
{
try
{
ViewBag.loginname = loginname;
if (string.IsNullOrEmpty(loginname))
{
throw new Exception("请输入登录名");
}
Ruanal.WebDomain.BLL.ManagerBll managerbll = new Ruanal.WebDomain.BLL.ManagerBll();
var model = managerbll.LoginIn(loginname, loginpwd);
if (model == null)
{
throw new Exception("登录失败！");
}
LoginTokenModel tokenmodel = new LoginTokenModel()
{
Id = model.ManagerId,
Name = model.Name,
SubName = model.SubName ?? ""
};
string name = Utils.SerializeObject(tokenmodel);
FormsAuthentication.SetAuthCookie(name, false, "/");
return(RedirectToAction("index", "home"));
}
catch (Exception ex)
{
ViewBag.msg = ex.Message;
return(View());
}
}
private void Verify(LoginTokenModel loginToken)
{
if (loginToken == null || loginToken.ExpiredTime < DateTime.Now)
{
throw new AuthenticationException();
}
}
public UserLoginTokenModel AddOrUpdateLoginToken(LoginTokenModel vm)
{
if (!IsExitsUser)
{
return(new UserLoginTokenModel());
}
var uLoginToken = _userLoginTokenRepository.GetByDomain(vm.Domain, _userId);
if (uLoginToken == null)
{
uLoginToken = new UserLoginToken();
_userLoginTokenRepository.Add(uLoginToken);
}
vm.ResetLoginToken();
//automap
//ServiceAutoMapModelMapper.MapExits(vm, uLoginToken);
uLoginToken.Domain = vm.Domain;
uLoginToken.Token = vm.Token;
uLoginToken.UserId = vm.UserId;
uLoginToken.ExpireDate = DateTime.Now.AddHours(12);
try
{
_userLoginTokenRepository.Save();
//automap
//return ServiceAutoMapModelMapper.CreateUserLoginTokenDto(uLoginToken);
return(new UserLoginTokenModel(uLoginToken));
}
catch (Exception ex) { }
return(new UserLoginTokenModel());
}
private string SetLoginTokensFromModel(LoginTokenModel loginToken)
{
if (loginToken != null)
{
return(loginToken.LoginTokenId + LoginTokenFieldDelimiter[0] + loginToken.UserId + LoginTokenFieldDelimiter[0] + loginToken.Token + LoginTokenFieldDelimiter[0] + loginToken.UserAgent + LoginTokenFieldDelimiter[0] + loginToken.LastLogIn.ToString());
}
return("");
}
public async Task LoginToken(LoginTokenModel model)
{
var result = new OperationResult();
// Simulate successful login
SimulateLogin(result);
// Output
await ResultContentAsync(result);
}
public async Task <LoginTokenModel> AddLoginToken(LoginTokenModel loginToken)
{
using (DynamoDbContext dbContext = new DynamoDbContext())
{
await dbContext.SaveAsync(loginToken);
var savedLoginToken = await dbContext.LoadAsync <LoginTokenModel>(loginToken.Token);
return(savedLoginToken);
}
}
private LoginTokenDto GetLoginTokenDtoFromModel(LoginTokenModel model)
{
return(new LoginTokenDto
{
LoginTokenId = Guid.Parse(model.LoginTokenId),
UserId = Guid.Parse(model.UserId),
Token = model.Token,
UserAgent = model.UserAgent,
LastLogIn = model.LastLogIn
});
}
protected override void OnAuthorization(AuthorizationContext filterContext)
{
base.OnAuthorization(filterContext);
if (User != null)
{
if (User.Identity.IsAuthenticated)
{
Token = Utils.GetTokenModel(User.Identity.Name);
//filterContext.HttpContext.Session["CurrUserId"] = Token.Id;
}
}
}
/// <summary>
/// Add auth.
/// </summary>
/// <param name="userId"></param>
/// <param name="loginType"></param>
/// <returns>Auth token</returns>
public async Task <string> Add(string userId, LoginTypes loginType)
{
try
{
var loginToken = new LoginTokenModel(userId, loginType);
var savedLoginToken = await _loginTokenRepository.AddLoginToken(loginToken);
return(savedLoginToken.Token);
}
catch (Exception ex)
{
LoggerFactory.GetInstance().AllLogger().Log(ex.Message);
throw ex;
}
}
public ServiceResponse AuthenticateToken(string token)
{
ServiceResponse response = new ServiceResponse();
LoginTokenModel tokenModel = GetEntity <LoginTokenModel>(StoredProcedures.AuthenticateToken,
new List <SearchValueData> {
new SearchValueData("Token", token)
});
if (tokenModel != null)
{
response = Common.GenerateResponse(Resource.Success, true);
response.Data = tokenModel;
}
else
{
response = Common.GenerateResponse(Resource.InvalidToken, true);
}
return(response);
}
public LoginTokenDataModel CheckUserCredentials(CredentialModel credentialModel)
{
try
{
LoginTokenDataModel loginTokenDataModel = new LoginTokenDataModel();
if (credentialModel != null)
{
List <KeyValuePair <string, object> > param = new List <KeyValuePair <string, object> >()
{
new KeyValuePair <string, object>("@username", credentialModel.UserName),
new KeyValuePair <string, object>("@isExternal", credentialModel.isExternal),
new KeyValuePair <string, object>("@password", EncryptManager.GetHashString(credentialModel.Password ?? string.Empty))
};
var data = DataExecutor.ExecuteDataTable(UtilityConstant.Procedures.Usp_CheckUserCredential, param);
if (data != null && data.Columns.Count > 1)
{
LoginTokenModel loginTokenModel = new LoginTokenModel()
{
ExpireTime = DateTime.Now.AddMinutes(30),
Message = string.Empty,
SecureId = Guid.NewGuid().ToString(),
UserData = data
};
loginTokenDataModel.UserData = data;
loginTokenDataModel.Message = "ValidUser";
loginTokenDataModel.Token = EncryptManager.Encrypt(JsonConvert.SerializeObject(loginTokenModel), AppSetting.GetAppSettingsData(UtilityConstant.AppConfigConstant.AppVariable, UtilityConstant.AppConfigConstant.SaltKey, string.Empty));
}
else
{
loginTokenDataModel.Message = data.Rows[0][0].ToString();
}
}
return(loginTokenDataModel);
}
catch (Exception ex)
{
throw;
}
}
private async Task ExtendTokenExpirationAsync(LoginTokenModel loginToken)
{
loginToken.ExpiredTime = DateTime.Now.AddMinutes(int.Parse(ConfigurationManager.AppSettings["AccessTokenMinutes"]));
await _loginTokenRepository.Update(loginToken);
}
