public async Task CreateAsync(AuthenticationTokenCreateContext context)
{
var clientid = context.Ticket.Properties.Dictionary["as:client_id"];
if (string.IsNullOrEmpty(clientid))
{
return;
}
var refreshTokenId = Guid.NewGuid().ToString("n");
var refreshTokenLifeTime = context.OwinContext.Get <string>("as:clientRefreshTokenLifeTime");
var token = new RefreshTokenInfo()
{
TokenId = refreshTokenId.GetHash(),
AppClientId = clientid,
Subject = context.Ticket.Identity.Name,
IssuedUtc = DateTime.UtcNow,
ExpiresUtc = DateTime.UtcNow.AddMinutes(Convert.ToDouble(refreshTokenLifeTime))
};
context.Ticket.Properties.IssuedUtc = token.IssuedUtc;
context.Ticket.Properties.ExpiresUtc = token.ExpiresUtc;
token.ProtectedTicket = context.SerializeTicket();
var result = await ContainerManager.Resolve <IAuthRepository>().AddRefreshToken(token);
if (result)
{
context.SetToken(refreshTokenId);
}
}
public Task SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo)
{
return(Task.Factory.StartNew(() =>
{
_configurationService.SetValue("RefreshToken", tokenInfo.RefreshToken);
}));
}
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo)
{
this.msAccountStatus = MSAccountStatus.Connected;
return(Task.Factory.StartNew(() =>
{
using (UsersContext db = new UsersContext())
{
MSAccount msAccount = db.MSAccounts.FirstOrDefault(u => u.UserName == this.User.Identity.Name);
if (msAccount != null)
{
if (tokenInfo.UserId != msAccount.MSUserId)
{
throw new LiveAuthException("invalid_user", "The account Id from the ticket does not match the current connected user.");
}
msAccount.RefreshToken = tokenInfo.RefreshToken;
db.Entry(msAccount).State = System.Data.EntityState.Modified;
}
else
{
// Insert name into the profile table
db.MSAccounts.Add(new MSAccount
{
MSUserId = tokenInfo.UserId,
RefreshToken = tokenInfo.RefreshToken,
UserName = this.User.Identity.Name
});
}
db.SaveChanges();
}
}));
}
public async Task <ResultModel <JwtResult <CoreUser> > > RefreshToken(CoreUser user)
{
var resultObj = new ResultModel <JwtResult <CoreUser> >();
var claims = GenerateClaims(user);
//var principal = new ClaimsPrincipal(identity);
var refreshTokenInfo = new RefreshTokenInfo()
{
UserId = user.Id,
// Expired Date Refresh Token
ExpiredDate = DateTime.Now.AddDays(37)
};
var identifier = user.CoreCredentials.First().Identifier;
var jwt = await TokenHelper.GenerateJwt(claims, _jwtFactory, identifier, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented, ReferenceLoopHandling = ReferenceLoopHandling.Ignore });
var result = new JwtResult <CoreUser>
{
Token = jwt,
RefreshToken = TokenHelper.GenerateRefreshToken(refreshTokenInfo, new JsonSerializerSettings {
Formatting = Formatting.Indented, ReferenceLoopHandling = ReferenceLoopHandling.Ignore
})
};
resultObj.Status = ResultStatus.Success;
resultObj.ExtendData = result;
_userDm.Update(user);
return(resultObj);
}
internal void TryRefreshToken(Action <LiveLoginResult> completionCallback)
{
LiveLoginResult result = new LiveLoginResult(LiveConnectSessionStatus.Unknown, null);
if (this.refreshTokenHandler != null)
{
if (this.refreshTokenInfo == null)
{
this.refreshTokenHandler.RetrieveRefreshTokenAsync().ContinueWith(t =>
{
if (t.Exception != null)
{
throw t.Exception;
}
this.refreshTokenInfo = t.Result;
this.RefreshToken(completionCallback);
});
return;
}
this.RefreshToken(completionCallback);
return;
}
this.OnRefreshTokenCompleted(result, completionCallback);
}
private void UpdateSession(LiveLoginResult result)
{
Debug.Assert(result != null);
if (result.Session != null)
{
// Set the AuthClient that is needed when refreshing a token.
result.Session.AuthClient = this.publicAuthClient;
// We have a new session, update the public property
this.loginStatus = result;
this.publicAuthClient.Session = result.Session;
if (this.refreshTokenHandler != null &&
!string.IsNullOrEmpty(result.Session.RefreshToken))
{
RefreshTokenInfo refreshInfo = new RefreshTokenInfo(result.Session.RefreshToken);
this.refreshTokenHandler.SaveRefreshTokenAsync(refreshInfo);
}
}
else if (this.loginStatus.Status == LiveConnectSessionStatus.Unknown &&
result.Status == LiveConnectSessionStatus.NotConnected)
{
this.loginStatus = result;
}
}
public static string GenerateRefreshToken(RefreshTokenInfo model, JsonSerializerSettings serializerSettings)
{
var modelString = JsonConvert.SerializeObject(model, serializerSettings);
var modelByte = System.Text.Encoding.UTF8.GetBytes(modelString);
return(Convert.ToBase64String(modelByte));
}
private async Task <string> CustomProviderAuthentication(RefreshTokenInfo refreshTokenInfo)
{
try
{
var ret = await _mobileServiceClient.InvokeApiAsync <CustomLoginResult>(
_customLoginControllerName, HttpMethod.Get, new Dictionary <string, string> {
{ "userId", refreshTokenInfo.UserId }, { "refreshToken", refreshTokenInfo.RefreshToken }
});
if (ret != null)
{
_mobileServiceClient.CurrentUser = new MobileServiceUser(ret.UserId)
{
MobileServiceAuthenticationToken = ret.MobileServiceAuthenticationToken
};
refreshTokenInfo.RefreshToken = ret.RefreshToken;
_accountStoreService.StoreTokenInSecureStore(refreshTokenInfo);
return(_mobileServiceClient.CurrentUser.MobileServiceAuthenticationToken);
}
else
{
return(string.Empty);
}
}
catch (MobileServiceInvalidOperationException)
{
return(string.Empty);
}
}
public Task <bool> RemoveRefreshToken(RefreshTokenInfo refreshToken)
{
_repository.DeleteItem(refreshToken);
var result = _unitOfWork.SaveChanges() > 0;
return(Task.FromResult(result));
}
public Task <bool> RemoveRefreshToken(RefreshTokenInfo refreshToken)
{
if (refreshToken != null)
{
_efRepositiry.Delete(refreshToken);
}
return(Task.FromResult(_efRepositiry.SaveChanges() > 0));
}
public HttpResponseMessage RefreshToken(RefreshTokenInfo refreshTokenInfo)
{
Validate("RefreshToken", refreshTokenInfo.RefreshToken);
Validate("ApiKey", refreshTokenInfo.ApiKey);
var response = GetRefreshTokenResponse(refreshTokenInfo.RefreshToken, refreshTokenInfo.ApiKey);
return(Request.CreateResponse(response.Json));
}
public void StoreTokenInSecureStore(RefreshTokenInfo user)
{
ClearSecureStore();
var account = new Account(user.UserId);
account.Properties.Add("token", user.RefreshToken);
account.Properties.Add("provider", user.Provider);
_accountStore.Save(account, _serviceId);
}
public Task SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo)
{
return(Task.Factory.StartNew(() =>
{
Console.WriteLine("------------------------");
Console.WriteLine("\r\nUserID = " + tokenInfo.UserId);
Console.WriteLine("\r\nRefresh Token = " + tokenInfo.RefreshToken);
Console.WriteLine("\r\n------------------------");
}));
}
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo)
{
// Note:
// 1) In order to receive refresh token, wl.offline_access scope is needed.
// 2) Alternatively, we can persist the refresh token.
return(Task.Factory.StartNew(() =>
{
this.refreshTokenInfo = tokenInfo;
}));
}
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo)
{
return(Task.Factory.StartNew(() =>
{
_refreshTokenInfo = tokenInfo;
_persister.Save(new LiveToken {
Value = _refreshTokenInfo.RefreshToken
});
}));
}
public LiveProvider(IPersister <LiveToken> persister)
{
persister.NotNull("persister");
_persister = persister;
var token = _persister.Load();
if (token != null)
{
_refreshTokenInfo = new RefreshTokenInfo(token.Value);
}
}
//添加刷新令牌
public async Task <bool> AddRefreshToken(RefreshTokenInfo refreshToken)
{
var existingToken = dBContext.RefreshTokenInfo.FirstOrDefault(ti => ti.client_id == refreshToken.client_id);
if (existingToken != null)
{
var result = await RemoveRefreshToken(existingToken);
}
dBContext.RefreshTokenInfo.Add(refreshToken);
//var tokenInfo = await dBContext.TokenInfo.FindAsync(ID);
//tokenInfo.refresh_token = refreshToken;
return(await dBContext.SaveChangesAsync() > 0);
}
public override async Task <bool> SaveToken(RefreshTokenInfo tokenInfo)
{
int result = 0;
try
{
OAuthClientRefreshToken token = new OAuthClientRefreshToken()
{
Value = tokenInfo.Value,
ProtectedTicket = tokenInfo.ProtectedTicket,
IssuedUtc = tokenInfo.IssuedUtc,
ExpiresUtc = tokenInfo.ExpiresUtc
};
try
{
ClientRepository.UnitOfWork.BeginTransaction();
var client = ClientRepository.TrackEntities.Where(m => m.ClientId == tokenInfo.ClientId).FirstOrDefault();
ClientRepository.UnitOfWork.Commit();
if (client == null)
{
return(false);
}
token.Client = client;
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
UserRepository.UnitOfWork.BeginTransaction();
User user = UserRepository.TrackEntities.Where(m => m.UserName == tokenInfo.UserName).FirstOrDefault();
UserRepository.UnitOfWork.Commit();
//User user = await UserManager.FindByNameAsync(tokenInfo.UserName);
//User user = await userStore.FindByNameAsync(tokenInfo.UserName);
if (user == null)
{
return(false);
}
token.User = user;
ClientRefreshTokenRepository.UnitOfWork.BeginTransaction();
result = await ClientRefreshTokenRepository.InsertAsync(token);
ClientRefreshTokenRepository.UnitOfWork.Commit();
}
catch (Exception ex)
{
Logger.Error("OAuthClientRefreshTokenStore.SaveToken错误：" + ex.ToString());
}
return(result > 0);
}
public async Task <bool> AddRefreshToken(RefreshTokenInfo token)
{
var existingToken = _repository.FirstOrDefault <RefreshTokenInfo>(r => r.Subject == token.Subject &&
r.AppClientId == token.AppClientId);
if (existingToken != null)
{
var result = await RemoveRefreshToken(existingToken);
}
_repository.Insert(token);
return(_unitOfWork.SaveChanges() > 0);
}
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo)
{
return(Task.Factory.StartNew(() =>
{
// Is stored in "OnSessionChanged"
//this.BeginInvoke(new Action<RefreshTokenInfo>
// (
// token =>
// {
// this.txtRefreshToken.Text = token.RefreshToken;
// }
// ), tokenInfo);
}));
}
Task <RefreshTokenInfo> IRefreshTokenHandler.RetrieveRefreshTokenAsync()
{
return(Task.Factory.StartNew <RefreshTokenInfo>(() =>
{
RefreshTokenInfo token = null;
using (UsersContext db = new UsersContext())
{
MSAccount msAccount = db.MSAccounts.FirstOrDefault(u => u.UserName == this.User.Identity.Name);
if (msAccount != null)
{
token = new RefreshTokenInfo(msAccount.RefreshToken, msAccount.MSUserId);
this.msAccountStatus = MSAccountStatus.Connected;
}
}
return token;
}));
}
public Task SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo)
{
// Note:
// 1) In order to receive refresh token, wl.offline_access scope is needed.
// 2) Alternatively, we can persist the refresh token.
return(Task.Factory.StartNew(() =>
{
if (File.Exists(path + "OneDrive.cloudmanager"))
{
File.Delete(path + "OneDrive.cloudmanager");
}
if (!Directory.Exists(Path.GetDirectoryName(path + "OneDrive.cloudmanager")))
{
Directory.CreateDirectory(Path.GetDirectoryName(path + "OneDrive.cloudmanager"));
}
File.AppendAllText(path + "OneDrive.cloudmanager", tokenInfo.RefreshToken);
}));
}
/// <summary>
/// Sign In
/// </summary>
/// <param name="signInModel"></param>
/// <returns></returns>
public async Task <ResultModel <JwtResult <CoreUser> > > SignIn(SignInModel signInModel)
{
var resultObj = new ResultModel <JwtResult <CoreUser> >();
var validateResultObj = Validate(signInModel.LoginTypeCode, signInModel.Identifier, signInModel.Secret);
if (validateResultObj.Status != ResultStatus.Success)
{
resultObj.Messages = validateResultObj.Messages;
resultObj.Status = validateResultObj.Status;
return(resultObj);
}
var user = validateResultObj.ExtendData;
var claims = GenerateClaims(user);
//var principal = new ClaimsPrincipal(identity);
var refreshTokenInfo = new RefreshTokenInfo()
{
UserId = user.Id,
// Expired Date Refresh Token
ExpiredDate = DateTime.Now.AddDays(37)
};
var jwt = await TokenHelper.GenerateJwt(claims, _jwtFactory, signInModel.Identifier, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented, ReferenceLoopHandling = ReferenceLoopHandling.Ignore });
var result = new JwtResult <CoreUser>
{
User = user,
Token = jwt,
RefreshToken = TokenHelper.GenerateRefreshToken(refreshTokenInfo, new JsonSerializerSettings {
Formatting = Formatting.Indented, ReferenceLoopHandling = ReferenceLoopHandling.Ignore
})
};
resultObj.Status = ResultStatus.Success;
resultObj.ExtendData = result;
_userDm.Update(user);
//result.User.CoreUserRoles.Clear();
result.User.CoreCredentials.Clear();
return(resultObj);
}
private async Task <string> IdentityProviderAuthentication(RefreshTokenInfo refreshTokenInfo)
{
_mobileServiceClient.CurrentUser = new MobileServiceUser(refreshTokenInfo.UserId)
{
MobileServiceAuthenticationToken = refreshTokenInfo.RefreshToken
};
try
{
var refreshed = await _mobileServiceClient.RefreshUserAsync();
_mobileServiceClient.CurrentUser = refreshed;
refreshTokenInfo.RefreshToken = refreshed.MobileServiceAuthenticationToken;
_accountStoreService.StoreTokenInSecureStore(refreshTokenInfo);
return(_mobileServiceClient.CurrentUser.MobileServiceAuthenticationToken);
}
catch //some providers doesn't support refresh
{
return(IsTokenActive(_mobileServiceClient.CurrentUser.MobileServiceAuthenticationToken) ?
_mobileServiceClient.CurrentUser.MobileServiceAuthenticationToken : string.Empty);
}
}
/// <summary>
/// 创建刷新令牌
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task CreateAsync(AuthenticationTokenCreateContext context)
{
var clientid = context.Ticket.Properties.Dictionary["client_id"];
if (string.IsNullOrEmpty(clientid))
{
return;
}
//真实设置refreshtoken的过期时间
var client = context.OwinContext.Get <AuthorizationInfo>("client");
var issued = DateTime.UtcNow;
var expired = issued.AddMinutes(Convert.ToDouble(client.refresh_token_life_time));
context.Ticket.Properties.IssuedUtc = issued;
context.Ticket.Properties.ExpiresUtc = expired;
//生成 refresh_token 并存储到数据库中
string ProtectedTicket = context.SerializeTicket();
var refreshTokenId = context.OwinContext.Get <string>("refreshToken");
//创建Refresh Token对象
var refreshToken = new RefreshTokenInfo()
{
//以散列格式存储RefreshTokenId
ID = refreshTokenId,
client_id = clientid,
protected_ticket = ProtectedTicket,
issued = issued,
expired = expired
};
using (RefreshTokenInfoRepository refreshTokenInfoRepository = new RefreshTokenInfoRepository())
{
var result = await refreshTokenInfoRepository.AddRefreshToken(refreshToken);
if (result)
{
context.SetToken(refreshTokenId);
}
}
await Task.FromResult <bool>(true);
}
/// <summary>
/// 获取刷新Token
/// </summary>
/// <param name="value">token值</param>
/// <returns></returns>
public override Task <RefreshTokenInfo> GetTokenInfo(string value)
{
RefreshTokenInfo tokenInfo = new RefreshTokenInfo();
try
{
tokenInfo = ClientRefreshTokenRepository.Entities.Where(m => m.Value == value).Select(m => new RefreshTokenInfo()
{
Value = m.Value,
IssuedUtc = m.IssuedUtc,
ExpiresUtc = m.ExpiresUtc,
ProtectedTicket = m.ProtectedTicket,
ClientId = m.Client.ClientId,
UserName = m.User.UserName
}).FirstOrDefault();
}
catch (Exception ex)
{
Logger.Error("OAuthClientRefreshTokenStore.GetTokenInfo错误：" + ex.ToString());
}
return(Task.FromResult(tokenInfo));
}
public Task <bool> AddRefreshToken(RefreshTokenInfo token)
{
_efRepositiry.Insert(token);
return(Task.FromResult(_efRepositiry.SaveChanges() > 0));
}
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo)
{
// RefreshToken is saved if the property is set in the mainwindow; so no action here...
return(Task.Factory.StartNew(() => { }));
}
/// <summary>
/// Wir speichern an dieser Stelle den Token nicht
/// </summary>
/// <param name="tokenInfo"></param>
/// <returns></returns>
public async Task SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo)
{
await Task.Delay(0);
}
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo)
{
// Note:
// 1) In order to receive refresh token, wl.offline_access scope is needed.
// 2) Alternatively, we can persist the refresh token.
return Task.Factory.StartNew(() =>
{
this.refreshTokenInfo = tokenInfo;
});
}
Task<RefreshTokenInfo> IRefreshTokenHandler.RetrieveRefreshTokenAsync()
{
return Task.Factory.StartNew<RefreshTokenInfo>(() =>
{
RefreshTokenInfo token = null;
using (UsersContext db = new UsersContext())
{
MSAccount msAccount = db.MSAccounts.FirstOrDefault(u => u.UserName == this.User.Identity.Name);
if (msAccount != null)
{
token = new RefreshTokenInfo(msAccount.RefreshToken, msAccount.MSUserId);
this.msAccountStatus = MSAccountStatus.Connected;
}
}
return token;
});
}
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo)
{
this.msAccountStatus = MSAccountStatus.Connected;
return Task.Factory.StartNew(() =>
{
using (UsersContext db = new UsersContext())
{
MSAccount msAccount = db.MSAccounts.FirstOrDefault(u => u.UserName == this.User.Identity.Name);
if (msAccount != null)
{
if (tokenInfo.UserId != msAccount.MSUserId)
{
throw new LiveAuthException("invalid_user", "The account Id from the ticket does not match the current connected user.");
}
msAccount.RefreshToken = tokenInfo.RefreshToken;
db.Entry(msAccount).State = System.Data.EntityState.Modified;
}
else
{
// Insert name into the profile table
db.MSAccounts.Add(new MSAccount
{
MSUserId = tokenInfo.UserId,
RefreshToken = tokenInfo.RefreshToken,
UserName = this.User.Identity.Name
});
}
db.SaveChanges();
}
});
}
//删除刷新令牌
private async Task <bool> RemoveRefreshToken(RefreshTokenInfo refreshToken)
{
dBContext.RefreshTokenInfo.Remove(refreshToken);
return(await dBContext.SaveChangesAsync() > 0);
}