/// <summary>
/// Callback function for each thread.
/// </summary>
/// <returns>void</returns>
static void FuncWaitCallback(object parmOrder)
{
Order order = parmOrder as Order;
AuthProvider authProvider = null;
if (order == null)
{
// errors here
}
// initialize auth provider
if (order.UserType == UserType.UnRealNameAuthedUser)
{
authProvider = new UserAuthProvider(order);
}
else
{
authProvider = new VipAuthProvider(order);
}
if (authProvider != null)
{
authProvider.Authenticate();
if (authProvider.IsAuthComplete())
{
authProvider.SubmitOrder();
}
}
}
private IIdentityServerProvider ProviderFactory()
{
IIdentityServerProvider provider;
switch (providerType)
{
case IdentityServerAuthProviderType.UserAuthProvider:
provider = new UserAuthProvider(this);
break;
case IdentityServerAuthProviderType.ServiceProvider:
provider = new ServiceAuthProvider(this);
break;
case IdentityServerAuthProviderType.ResourcePasswordFlowProvider:
provider = new ResourcePasswordFlowAuthProvider(this);
break;
default:
provider = new ImpersonationAuthProvider(this);
break;
}
provider.Init().Wait();
return(provider);
}
public void IsInitialAuthenticateRequest_ReturnsFalseWhenValidUrlAndHasAccessToken()
{
// Arrange
const string url = "http://localhost:5000/Auth/IdentityServer";
const string accessToken = "A1234";
var httpRequestFake = A.Fake <IRequest>();
A.CallTo(() => httpRequestFake.AbsoluteUri).Returns(url);
var authTokensFake = A.Fake <IAuthTokens>();
A.CallTo(() => authTokensFake.AccessToken).Returns(accessToken);
var provider = new UserAuthProvider(new TestIdentityServerAuthProviderSettings())
{
CallbackUrl = url
};
// Act
var result = provider.IsInitialAuthenticateRequest(httpRequestFake, authTokensFake).Result;
// Assert
result.Should().Be(false);
A.CallTo(() => httpRequestFake.AbsoluteUri).MustHaveHappened();
A.CallTo(() => authTokensFake.AccessToken).MustHaveHappened();
}
public void IsAuthorized_RequestNullSessionNull_ReturnsFalse()
{
var provider = new UserAuthProvider(new TestIdentityServerAuthProviderSettings());
// Act
var result = provider.IsAuthorized(null, null);
result.Should().Be(false);
}
public void IsAuthorized_RequestNull_SessionNotAuthenticated_ReturnsFalse()
{
var authSessionFake = A.Fake <IAuthSession>();
var authTokenFake = A.Fake <IAuthTokens>();
authSessionFake.IsAuthenticated = false;
var provider = new UserAuthProvider(new TestIdentityServerAuthProviderSettings());
// Act
var result = provider.IsAuthorized(authSessionFake, authTokenFake);
result.Should().Be(false);
}
public void IsAuthorized_RequestNull_SessionAuthenticated_AccessTokenValid_ReturnsTrue()
{
// Arrange
var authSessionFake = A.Fake <IAuthSession>();
var authTokenFake = A.Fake <IAuthTokens>();
authSessionFake.IsAuthenticated = true;
authTokenFake.AccessToken = "A12345";
var provider = new UserAuthProvider(new TestIdentityServerAuthProviderSettings());
// Act
var result = provider.IsAuthorized(authSessionFake, authTokenFake);
result.Should().Be(true);
}
public void IsInitialAuthenticateRequest_ReturnsFalseWhenAbsoluteUriIsNotValid(string absoluteUri)
{
// Arrange
var httpRequestFake = A.Fake <IRequest>();
A.CallTo(() => httpRequestFake.AbsoluteUri).Returns(absoluteUri);
var authTokensFake = A.Fake <IAuthTokens>();
var provider = new UserAuthProvider(new TestIdentityServerAuthProviderSettings())
{
CallbackUrl = "http://localhost:5000/Auth/IdentityServer"
};
// Act
var result = provider.IsInitialAuthenticateRequest(httpRequestFake, authTokensFake).Result;
// Assert
result.Should().Be(false);
A.CallTo(() => httpRequestFake.AbsoluteUri).MustHaveHappened();
}
public string CreateOrMergeAuthSession(IAuthSession authSession, IAuthTokens tokens)
{
using (var redis = factory.GetClient())
{
UserAuthProvider authProvider = null;
var oAuthProviderId = GetAuthProviderByUserId(redis, tokens.Provider, tokens.UserId);
if (!oAuthProviderId.IsNullOrEmpty())
authProvider = redis.As<UserAuthProvider>().GetById(oAuthProviderId);
var userAuth = GetUserAuth(redis, authSession, tokens)
?? new UserAuth { Id = redis.As<UserAuth>().GetNextSequence(), };
if (authProvider == null)
{
authProvider = new UserAuthProvider {
Id = redis.As<UserAuthProvider>().GetNextSequence(),
UserAuthId = userAuth.Id,
Provider = tokens.Provider,
UserId = tokens.UserId,
};
var idx = IndexProviderToUserIdHash(tokens.Provider);
redis.SetEntryInHash(idx, tokens.UserId, authProvider.Id.ToString(CultureInfo.InvariantCulture));
}
authProvider.PopulateMissing(tokens);
userAuth.PopulateMissing(authProvider);
userAuth.ModifiedDate = DateTime.UtcNow;
if (authProvider.CreatedDate == default(DateTime))
authProvider.CreatedDate = userAuth.ModifiedDate;
authProvider.ModifiedDate = userAuth.ModifiedDate;
redis.Store(userAuth);
redis.Store(authProvider);
redis.AddItemToSet(IndexUserAuthAndProviderIdsSet(userAuth.Id), authProvider.Id.ToString(CultureInfo.InvariantCulture));
return userAuth.Id.ToString(CultureInfo.InvariantCulture);
}
}
public string CreateOrMergeAuthSession(IAuthSession authSession, IAuthTokens tokens)
{
var userAuth = GetUserAuth(authSession, tokens) ?? new UserAuth();
using (var db = dbFactory.Open())
{
var oAuthProvider = db.Select<UserAuthProvider>(q =>
q.Provider == tokens.Provider && q.UserId == tokens.UserId).FirstOrDefault();
if (oAuthProvider == null)
{
oAuthProvider = new UserAuthProvider {
Provider = tokens.Provider,
UserId = tokens.UserId,
};
}
oAuthProvider.PopulateMissing(tokens);
userAuth.PopulateMissing(oAuthProvider);
userAuth.ModifiedDate = DateTime.UtcNow;
if (userAuth.CreatedDate == default(DateTime))
userAuth.CreatedDate = userAuth.ModifiedDate;
db.Save(userAuth);
oAuthProvider.UserAuthId = userAuth.Id != default(int)
? userAuth.Id
: (int)db.GetLastInsertId();
if (oAuthProvider.CreatedDate == default(DateTime))
oAuthProvider.CreatedDate = userAuth.ModifiedDate;
oAuthProvider.ModifiedDate = userAuth.ModifiedDate;
db.Save(oAuthProvider);
return oAuthProvider.UserAuthId.ToString(CultureInfo.InvariantCulture);
};
}
public UserService(UserRepository repository,
UserAuthProvider userAuthProvider
) : base(repository)
{
_userAuthProvider = userAuthProvider;
}
