private async Task<TokenResponse> ProcessAuthorizationCodeRequestAsync(ValidatedTokenRequest request)
{
var response = new TokenResponse
{
AccessToken = await CreateAccessTokenAsync(request),
AccessTokenLifetime = request.Client.AccessTokenLifetime
};
if (request.AuthorizationCode.IsOpenId)
{
var idToken = await _tokenService.CreateIdentityTokenAsync(request.AuthorizationCode.Subject, request.AuthorizationCode.Client, request.AuthorizationCode.RequestedScopes, false, request.Raw);
var jwt = await _tokenService.CreateSecurityTokenAsync(idToken);
response.IdentityToken = jwt;
}
return response;
}
static string CallApi(TokenResponse token, string endpoint)
{
Console.WriteLine(token.AccessToken);
var client = new HttpClient();
client.SetBearerToken(token.AccessToken);
return client.GetStringAsync(endpoint).Result;
}
private async Task<TokenResponse> ProcessTokenRequestAsync(ValidatedTokenRequest request)
{
var response = new TokenResponse
{
AccessToken = await CreateAccessTokenAsync(request),
AccessTokenLifetime = request.Client.AccessTokenLifetime
};
return response;
}
public void TestPropertiesAndSerialisation()
{
TokenResponse token = new TokenResponse()
{
AccessToken = "token",
ExpiresIn = 120,
RefreshToken = "refresh",
Territory = "gb",
UserId = Guid.NewGuid()
};
JToken json = token.ToJToken();
TokenResponse rehydrated = TokenResponse.FromJToken(json, null);
Assert.AreEqual(token.AccessToken, rehydrated.AccessToken, "Expected AccessToken to match");
Assert.AreEqual(token.ExpiresIn, rehydrated.ExpiresIn, "Expected ExpiresIn to match");
Assert.AreEqual(token.RefreshToken, rehydrated.RefreshToken, "Expected RefreshToken to match");
Assert.AreEqual(token.Territory, rehydrated.Territory, "Expected Territory to match");
Assert.AreEqual(token.UserId, rehydrated.UserId, "Expected UserId to match");
}
private async Task <ProviderTokenResponse> CreateProviderTokenResponse(ITurnContext context, TokenResponse tokenResponse)
{
var adapter = context.Adapter as BotFrameworkAdapter;
var tokens = await adapter.GetTokenStatusAsync(context, context.Activity.From.Id);
var match = Array.Find(tokens, t => t.ConnectionName == tokenResponse.ConnectionName);
return(new ProviderTokenResponse
{
AuthenticationProvider = match.ServiceProviderDisplayName.GetAuthenticationProvider(),
TokenResponse = tokenResponse,
});
}
public virtual ODataBatch BuildODataBatchClient(Action <HttpRequestMessage> beforeRequest = null,
Action <HttpResponseMessage> afterResponse = null, TokenResponse token = null, string odataRouteName = "Test")
{
return(new ODataBatch(BuildODataClient(beforeRequest, afterResponse, token, odataRouteName)));
}
public virtual async Task TestStringFormattersInCustomActions()
{
IValueChecker valueChecker = A.Fake <IValueChecker>();
IStringCorrector stringCorrector1 = A.Fake <IStringCorrector>();
IStringCorrector stringCorrector2 = A.Fake <IStringCorrector>();
A.CallTo(() => stringCorrector1.CorrectString(A <string> .Ignored))
.ReturnsLazily(correctString =>
{
string arg = correctString.GetArgument <string>("input");
return("ONE" + arg);
});
A.CallTo(() => stringCorrector2.CorrectString(A <string> .Ignored))
.ReturnsLazily(correctString =>
{
string arg = correctString.GetArgument <string>("input");
return("TWO" + arg);
});
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = (manager, services) =>
{
manager.RegisterInstance(valueChecker);
manager.RegisterInstance(stringCorrector2, overwriteExciting: false);
manager.RegisterInstance(stringCorrector1, overwriteExciting: false);
}
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token);
await client.Controller <TestModelsController, TestModel>()
.Action(nameof(TestModelsController.StringFormattersTests))
.Set(new TestModelsController.StringFormattersTestsParameters
{
simpleString = "simpleString",
stringsArray = new[] { "stringsArray1", "stringsArray2" },
stringsArray2 = new[] { "stringsArray1", "stringsArray2" },
entitiesArray = new[]
{
new TestModel
{
StringProperty = "StringProperty1", Id = 2, Version = 2
},
new TestModel
{
StringProperty = "StringProperty2", Id = 3, Version = 3
}
},
simpleDto = new TestModel {
StringProperty = "StringProperty", Id = 1, Version = 1
}
}).ExecuteAsync();
A.CallTo(() => valueChecker.CheckValue("ONETWOsimpleString"))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue(A <List <string> > .That.Matches(strs => strs.SequenceEqual(new List <string> {
"ONETWOstringsArray1", "ONETWOstringsArray2"
}))))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue(A <TestModel> .That.Matches(tm => tm.StringProperty == "ONETWOStringProperty")))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue(A <List <TestModel> > .That.Matches(tms => tms.First().StringProperty == "ONETWOStringProperty1" && tms.Last().StringProperty == "ONETWOStringProperty2")))
.MustHaveHappenedOnceExactly();
A.CallTo(() => stringCorrector1.CorrectString(A <string> .Ignored))
.MustHaveHappenedANumberOfTimesMatching(times => times == 8);
A.CallTo(() => stringCorrector2.CorrectString(A <string> .Ignored))
.MustHaveHappenedANumberOfTimesMatching(times => times == 8);
}
}
internal async Task <TokenResponseValidationResult> ValidateTokenResponseAsync(TokenResponse response, AuthorizeState state, bool requireIdentityToken = true)
{
_logger.LogTrace("ValidateTokenResponse");
// token response must contain an access token
if (response.AccessToken.IsMissing())
{
return(new TokenResponseValidationResult("Access token is missing on token response."));
}
if (requireIdentityToken)
{
// token response must contain an identity token (openid scope is mandatory)
if (response.IdentityToken.IsMissing())
{
return(new TokenResponseValidationResult("Identity token is missing on token response."));
}
}
if (response.IdentityToken.IsPresent())
{
// if identity token is present, it must be valid
var validationResult = await _tokenValidator.ValidateAsync(response.IdentityToken);
if (validationResult.IsError)
{
return(new TokenResponseValidationResult(validationResult.Error ?? "Identity token validation error"));
}
// validate nonce
if (state != null)
{
if (!ValidateNonce(state.Nonce, validationResult.User))
{
return(new TokenResponseValidationResult("Invalid nonce."));
}
}
// validate at_hash
var atHash = validationResult.User.FindFirst(JwtClaimTypes.AccessTokenHash);
if (atHash == null)
{
if (_options.Policy.RequireAccessTokenHash)
{
return(new TokenResponseValidationResult("at_hash is missing."));
}
}
else
{
if (!_crypto.ValidateHash(response.AccessToken, atHash.Value, validationResult.SignatureAlgorithm))
{
return(new TokenResponseValidationResult("Invalid access token hash."));
}
}
return(new TokenResponseValidationResult(validationResult));
}
return(new TokenResponseValidationResult((IdentityTokenValidationResult)null));
}
private HttpResponseMessage CreateTokenResponse(GenericXmlSecurityToken token, string scope)
{
var response = new TokenResponse();
if (ConfigurationRepository.AdfsIntegration.PassThruAuthenticationToken)
{
response.AccessToken = token.TokenXml.OuterXml;
response.ExpiresIn = (int)(token.ValidTo.Subtract(DateTime.UtcNow).TotalSeconds);
}
else
{
var bridge = new AdfsBridge(ConfigurationRepository);
if (ConfigurationRepository.Keys.DecryptionCertificate != null)
{
var configuration = new SecurityTokenHandlerConfiguration
{
AudienceRestriction = { AudienceMode = AudienceUriMode.Never },
CertificateValidationMode = X509CertificateValidationMode.None,
RevocationMode = X509RevocationMode.NoCheck,
CertificateValidator = X509CertificateValidator.None,
ServiceTokenResolver = SecurityTokenResolver.CreateDefaultSecurityTokenResolver(
new ReadOnlyCollection<SecurityToken>(new SecurityToken[] { new X509SecurityToken(ConfigurationRepository.Keys.DecryptionCertificate) }), false)
};
var handler = SecurityTokenHandlerCollection.CreateDefaultSecurityTokenHandlerCollection(configuration);
response = bridge.ConvertSamlToJwt(token.ToSecurityToken(handler), scope);
}
else
{
response = bridge.ConvertSamlToJwt(token.ToSecurityToken(), scope);
}
}
return Request.CreateResponse<TokenResponse>(HttpStatusCode.OK, response);
}
/// <summary>
/// Finalises authorisation to obtain a token
/// </summary>
/// <param name="authorizationCode">The authorization code.</param>
/// <param name="refreshToken">The refresh token.</param>
/// <param name="resultCode">The result code for the process so far.</param>
/// <returns>
/// Whether the token was retrieved
/// </returns>
internal async Task<Response<AuthResultCode>> ObtainToken(string authorizationCode, string refreshToken, AuthResultCode resultCode)
{
// Next get a token, for now just return whether we got the authorization code...
if (!string.IsNullOrEmpty(authorizationCode) || !string.IsNullOrEmpty(refreshToken))
{
ManualResetEventSlim waiter = new ManualResetEventSlim();
Response<AuthResultCode> result = null;
this.TokenCallInProgress = true;
// Set up auth code and secret...
this._tokenCommand.AuthorizationCode = authorizationCode;
this._tokenCommand.ClientId = this._clientId;
this._tokenCommand.ClientSecret = this._clientSecret;
this._tokenCommand.RefreshToken = refreshToken;
try
{
var tokenResponse = await this._tokenCommand.InvokeAsync();
if (tokenResponse.Result != null)
{
result = new Response<AuthResultCode>(null, AuthResultCode.Success, Guid.Empty);
this.TokenResponse = tokenResponse.Result;
}
}
catch
{
result = new Response<AuthResultCode>(null, AuthResultCode.Unknown, Guid.Empty);
}
this.TokenCallInProgress = false;
return result;
}
else
{
return new Response<AuthResultCode>(null, resultCode, Guid.Empty);
}
}
private void OnSuccessLogin(string response)
{
TokenResponse tokenData = JsonUtility.FromJson <TokenResponse>(response);
this.userManager.SaveUserToken(tokenData.access_token);
}
public async Task <UserCredential> LoadUserCredentialsAsync(string key)
{
TokenResponse token = await _flow.LoadTokenAsync(key, CancellationToken.None) ?? throw new FileLoadException("Failed to load the user's Google access token from the data store.");
return(new UserCredential(_flow, key, token));
}
public Tokens(TokenResponse response)
{
AccessToken = response.AccessToken;
RefreshToken = response.RefreshToken;
}
private async void LoginMethod()
{
this.IsRunning = true;
this.IsEnabled = false;
Response internet_connection = await apiService.CheckConnection();
if (!internet_connection.IsSuccess)
{
this.IsRunning = false;
this.IsEnabled = true;
await Application.Current.MainPage.DisplayAlert(
Languages.ErrorTitle,
internet_connection.Message,
Languages.AcceptButton);
return;
}
TokenResponse token = await apiService.GetToken(
"https://landsapi1.azurewebsites.net",
Email,
Password);
if (token == null)
{
this.IsRunning = false;
this.IsEnabled = true;
await Application.Current.MainPage.DisplayAlert(
Languages.ErrorTitle,
Languages.ErrorUhandledDescription,
Languages.AcceptButton);
return;
}
if (token.AccessToken == null)
{
this.Password = "";
this.IsRunning = false;
this.IsEnabled = true;
await Application.Current.MainPage.DisplayAlert(
Languages.ErrorTitle,
token.ErrorDescription,
Languages.AcceptButton);
return;
}
Response responseUsersList = await apiService.GetList <UserInfo>(
"https://landsapi1.azurewebsites.net",
"/api",
"/Users");
if (!responseUsersList.IsSuccess)
{
await Application.Current.MainPage.DisplayAlert(
Languages.ErrorTitle,
responseUsersList.Message,
Languages.AcceptButton);
return;
}
List <UserInfo> listUsers = (List <UserInfo>)responseUsersList.Result;
var user = listUsers.Where(u => u.Email == this.Email).FirstOrDefault();
if (this.IsRemembered)
{
Settings.Token = token.AccessToken;
Settings.TokenType = token.TokenType;
Settings.UserID = user.UserId.ToString();
}
MainViewModel.GetInstance().User = user;//user;
MainViewModel.GetInstance().Token = token.AccessToken;
MainViewModel.GetInstance().TokenType = token.TokenType;
this.IsRunning = false;
this.IsEnabled = true;
//var menuItem = new MenuItemViewModel()
//{
// UserName = user.FirstName
var Main = MainViewModel.GetInstance();
Main.LoadMenuItems();
Main.UserName = string.Format("Hola {0}", user.FirstName);
Main.ImageSource = user.ImageFullPath;
if (user.ImageFullPath == "noimage")
{
Main.ImageSource = "cameraImage";
}
Main.Lands = new LandsViewModel();
var masterPage = new MasterPage();
MainViewModel.GetInstance().MasterPage = masterPage;
Application.Current.MainPage = masterPage;
}
private static void SetCurrentTokens(TokenResponse tokenResponse)
{
tokens = tokenResponse;
}
public static void SignIn(string path)
{
tokenPath = path;
string logoutUri = OneDriveClient.GetDefaultLogoutUri();
string authorizationUri = OneDriveClient.GetDefaultAuthorizationUri();
AuthenticationResult authenticationResult = null;
BrowserAuthenticationWindow authWindow = new BrowserAuthenticationWindow();
authWindow.Browser.Navigated += (sender, args) =>
{
if (string.Equals(args.Uri.AbsolutePath, "/oauth20_logout.srf", StringComparison.OrdinalIgnoreCase))
{
// The logout page has finished loading, so we can now load the login page.
authWindow.Browser.Navigate(authorizationUri);
}
// If the browser is directed to the redirect URI, the new URI will contain the access code that we can use to
// get a token for OneDrive.
if (string.Equals(args.Uri.AbsolutePath, "ietf:wg:oauth:2.0:oob", StringComparison.OrdinalIgnoreCase))
{
// We were directed back to the redirect URI. Extract the code from the query string
Dictionary <string, string> queryParametes = args.Uri.GetQueryParameters();
authenticationResult = new AuthenticationResult()
{
Code = queryParametes["code"]
};
// All done. Close the window.
authWindow.Close();
}
};
authWindow.Closed += (sender, args) =>
{
if (authenticationResult == null)
{
AuthComplete.Set();
return;
}
Task.Factory.StartNew(async() =>
{
TokenResponse currentToken = await OneDriveClient.GetAccessToken(authenticationResult).ConfigureAwait(false);
currentToken.SaveProtectedToken(tokenPath);
TokenSuccess = true;
AuthComplete.Set();
});
};
authWindow.Loaded += (sender, args) =>
{
authWindow.Browser.Navigate(logoutUri);
SyncPro.UI.NativeMethods.User32.SetForegroundWindow(new WindowInteropHelper(authWindow).Handle);
};
authWindow.ShowDialog();
AuthComplete.WaitOne();
}
public object RefreshOauth()
{
var CLIENT_ID = "570313910467-h8raudku9n9n65118tqndopih9breo53.apps.googleusercontent.com";
var CLIENT_SECRET = "T8vlM82EEb82IAtDSaey-Oet";
ClientSecrets secrets = new ClientSecrets
{
ClientId = CLIENT_ID,
ClientSecret = CLIENT_SECRET
};
TokenResponse token = new TokenResponse
{
AccessToken = "sfd",
RefreshToken = "1/RcTEm-ZKEtBZzS2jOVLONQcmhtEpRZ7r2zny2HjWtMY"
};
IAuthorizationCodeFlow flow =
new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = secrets,
Scopes = new string[] { DriveService.Scope.Drive }
});
UserCredential credential = new UserCredential(flow, "me", token);
bool success = credential.RefreshTokenAsync(CancellationToken.None).Result;
token = credential.Token;
string access = token.AccessToken;
var dbCtx = new CompassDBEntities();
var oauthVal = new DriveOauth();
oauthVal.Id = 1;
var DriveAuth = dbCtx.DriveOauths.Find(oauthVal.Id);
DriveAuth.AccessToken = token.AccessToken;
DriveAuth.ExpireTime = token.ExpiresInSeconds.ToString();
DriveAuth.IssueTime = token.Issued.ToString();
dbCtx.SaveChanges();
return token;
}
/// <summary>
/// Calls create customer and checks for 401 UnAuthorized error
/// </summary>
/// <returns>customer Id</returns>
public async Task <String> CreateCustomerApiCall()
{
try
{
output("Making QBO API Call.");
Helper.InitializeContext initialize = new Helper.InitializeContext(dictionary["accessToken"], dictionary["refreshToken"], dictionary["realmId"]);
ServiceContext servicecontext = initialize.InitializeQBOServiceContextUsingoAuth();
Customer customer = QBOApp.CreateCustomer(servicecontext);
return(customer.Id);
}
catch (IdsException ex)
{
if (ex.Message == "Unauthorized-401")
{
output("Invalid/Expired Access Token.");
//if you get a 401 token expiry then perform token refresh
TokenResponse refreshAccessTokenResponse = await Helper.OAuth2Helper.refreshAccessToken(refreshToken, clientID, clientSecret, discoveryUrl);
if (refreshAccessTokenResponse.HttpStatusCode == HttpStatusCode.OK)
{
//save the refresh token in persistent store so that it can be used to refresh short lived access tokens
refreshToken = refreshAccessTokenResponse.RefreshToken;
if (!dictionary.ContainsKey("refreshToken"))
{
dictionary.Add("refreshToken", refreshToken);
}
else
{
dictionary["refreshToken"] = refreshToken;
}
output("Refresh token obtained.");
accessToken = refreshAccessTokenResponse.AccessToken;
output("Access token obtained.");
if (!dictionary.ContainsKey("accessToken"))
{
dictionary.Add("accessToken", accessToken);
}
else
{
dictionary["accessToken"] = accessToken;
}
}
if ((dictionary.ContainsKey("accessToken")) && (dictionary.ContainsKey("refreshToken")) && (dictionary.ContainsKey("realmId")))
{
// update data store with new access and refresh token values
Helper.InitializeContext initialize = new Helper.InitializeContext(dictionary["accessToken"], dictionary["refreshToken"], dictionary["realmId"]);
ServiceContext servicecontext = initialize.InitializeQBOServiceContextUsingoAuth();
Customer customer = QBOApp.CreateCustomer(servicecontext);
return(customer.Id);
}
return("Cannot make refresh access token API call");
}
else
{
output(ex.Message);
return(ex.Message);
}
}
}
/// <summary>
/// Processes the token post request.
/// </summary>
/// <param name="context">The context.</param>
private void ProcessTokenPostRequest(HttpContext context)
{
TokenResponse tokenResponse = new TokenResponse();
try
{
string clientId = context.Request.Form[ClientIdParam];
string clientSecret = context.Request.Form[ClientSecretParam];
string code = context.Request.Form[CodeParam];
string grantType = context.Request.Form[GrantTypeParam];
if (string.IsNullOrEmpty(grantType))
{
grantType = GrantTypeAuthorizationCodeValue;
}
if (string.IsNullOrEmpty(clientId))
{
throw new ArgumentOutOfRangeException("clientId");
}
if (string.IsNullOrEmpty(clientSecret))
{
throw new ArgumentOutOfRangeException("clientSecret");
}
if (string.IsNullOrEmpty(code))
{
throw new ArgumentOutOfRangeException("code");
}
ApplicationInfo appInfo = this.store.GetApplicationByClientId(clientId);
if (appInfo == null)
{
throw new SecurityException("Unknown client id.");
}
if (string.CompareOrdinal(appInfo.ClientSecret, clientSecret) != 0)
{
throw new SecurityException("Invalid client secret.");
}
OAuth2Code parsedCode = OAuth2Code.Parse(code);
if (!parsedCode.Validate(this.tokenSecret) ||
parsedCode.Expires < DateTime.UtcNow ||
parsedCode.ApplicationName != appInfo.Name)
{
throw new SecurityException("Invalid code.");
}
// TODO: Implement refresh tokens.
// TODO: Use a specific access token class.
tokenResponse.TokenType = "Bearer";
OAuth2Code accessToken = OAuth2Code.Generate(
parsedCode.AccountId,
parsedCode.ApplicationName,
DateTime.UtcNow + TokenLifetime,
this.tokenSecret);
tokenResponse.AccessToken = accessToken.ToString();
tokenResponse.ExpiresInSeconds = (int)TokenLifetime.TotalSeconds;
}
catch (ArgumentException argEx)
{
tokenResponse.Error = "invalid_request";
tokenResponse.ErrorDescription = argEx.Message;
}
catch (SecurityException securityEx)
{
tokenResponse.Error = "invalid_client";
tokenResponse.ErrorDescription = securityEx.Message;
}
context.Response.ContentType = "application/json";
context.Response.StatusCode = tokenResponse.Error != null ?
(int)System.Net.HttpStatusCode.BadRequest :
(int)System.Net.HttpStatusCode.OK;
TokenResponseSerializer.WriteObject(context.Response.OutputStream, tokenResponse);
}
private async void ContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
StorageFolder folder = ApplicationData.Current.LocalFolder;
StorageFile file = await folder.GetFileAsync("token.txt");
var tokenContent = await FileIO.ReadTextAsync(file);
TokenResponse token = JsonConvert.DeserializeObject <TokenResponse>(tokenContent);
// Lay thong tin ca nhan bang token.
HttpClient client2 = new HttpClient();
client2.DefaultRequestHeaders.Add("Authorization", "Basic " + token.token);
var resp = client2.GetAsync("http://2-dot-backup-server-002.appspot.com/_api/v2/members/information").Result;
Debug.WriteLine(await resp.Content.ReadAsStringAsync());
var userInfoContent = await resp.Content.ReadAsStringAsync();
Member userInfoJson = JsonConvert.DeserializeObject <Member>(userInfoContent);
// do validate first.
this.currentSong.name = this.SongName.Text;
this.currentSong.description = this.Description.Text;
this.currentSong.singer = this.Singer.Text;
this.currentSong.author = this.Author.Text;
this.currentSong.thumbnail = this.Thumbnail.Text;
this.currentSong.link = this.Link.Text;
//Debug.WriteLine("Action success.");
//currentSong.memberId = userInfoJson.id;
string content = await API_Handle.Create_Song(this.currentSong);
// đến đây là đã có mp3 đã lên rồi.
//Load trang khi truy cập
//ProgressRing.Visibility = Visibility.Visible;
//ProgressRing.IsActive = true;
//SongLoading.Visibility = Visibility.Visible;
//await Task.Delay(3000);
//ProgressRing.IsActive = false;
//ProgressRing.Visibility = Visibility.Collapsed;
//SongLoading.Visibility = Visibility.Collapsed;
var dialog = new Windows.UI.Popups.MessageDialog("Upload thành công");
dialog.Commands.Add(new Windows.UI.Popups.UICommand("OK")
{
Id = 1
});
dialog.CancelCommandIndex = 1;
await dialog.ShowAsync();
//reset Form Create Song
SongName.Text = "";
Description.Text = "";
Singer.Text = "";
Author.Text = "";
Thumbnail.Text = "";
Link.Text = "";
}
public ActionResult <SignInResultModel> SignIn(
[FromForm] string sEmail
, [FromForm] string sPW)
{
//결과용
ApiResultReady rrResult = new ApiResultReady(this);
//로그인 처리용 모델
SignInResultModel armResult = new SignInResultModel();
rrResult.ResultObject = armResult;
//API 호출 시간
DateTime dtNow = DateTime.Now;
//사인인 시도 기록
GlobalSign.LogAdd_DB(
1
, ModelDB.UserSignLogType.SignIn
, 0
, string.Format("SignIn 시도 - {0}, {1}", sEmail, sPW));
//검색된 유저
User findUser = null;
using (SpaNetCoreFoundationContext db1 = new SpaNetCoreFoundationContext())
{
//유저 검색
findUser
= db1.User
.FirstOrDefault(m =>
m.SignEmail == sEmail &&
m.Password == sPW);
}//end using db1
if (findUser != null)
{
//토큰 요청
TokenResponse tr = GlobalStatic.TokenProc.RequestTokenAsync(sEmail, sPW).Result;
if (true == tr.IsError)
{//에러가 있다.
rrResult.InfoCode = "1";
rrResult.Message = "아이디나 비밀번호가 틀렸습니다.";
}
else
{//에러가 없다.
using (SpaNetCoreFoundationContext db1 = new SpaNetCoreFoundationContext())
{
//기존 로그인한 유저 검색
UserSignIn[] arrSL
= db1.UserSignIn
.Where(m => m.idUser == findUser.idUser)
.ToArray();
//기존 로그인 토큰 제거
foreach (UserSignIn itemUSI in arrSL)
{
//리플레시 토큰 제거
if ((null != itemUSI.RefreshToken) &&
(string.Empty != itemUSI.RefreshToken))
{
TokenRevocationResponse trr
= GlobalStatic.TokenProc
.RevocationTokenAsync(itemUSI.RefreshToken)
.Result;
}
}//end foreach itemUSI
//기존 로그인한 유저 정보 제거
db1.UserSignIn.RemoveRange(arrSL);
//db 적용
db1.SaveChanges();
//로그인 되어있는 유저정보 저장
UserSignIn slItem = new UserSignIn();
slItem.idUser = findUser.idUser;
slItem.RefreshToken = tr.RefreshToken;
slItem.SignInDate = dtNow;
slItem.RefreshDate = dtNow;
//기존 로그인한 유저 정보 제거
db1.UserSignIn.Add(slItem);
//db 적용
db1.SaveChanges();
//로그인한 유저에게 전달할 정보
armResult.idUser = findUser.idUser;
armResult.Email = findUser.SignEmail;
armResult.ViewName = armResult.Email;
armResult.access_token = tr.AccessToken;
armResult.refresh_token = tr.RefreshToken;
//성공 로그
//사인인 성공 기록
GlobalSign.LogAdd_DB(
1
, ModelDB.UserSignLogType.SignIn
, findUser.idUser
, string.Format("SignIn 성공 - {0}", sEmail));
}//end using db1
}
}
else
{
rrResult.InfoCode = "1";
rrResult.Message = "아이디나 비밀번호가 틀렸습니다.";
}
return(rrResult.ToResult(armResult));
}
public async Task <IResponse <BasketResponse> > PurchaseBasketAsync(PurchaseBasketCreateOption purchaseBasketCreateOption, TokenResponse token)
{
Urls.BaseUrl = _settings.GetConfigSetting <string>(SettingKeys.Integration.DTCM.BaseUrl);
IRequestCreateOptions <PurchaseBasketCreateOption> requestCreateOptions = new RequestCreateOptions <PurchaseBasketCreateOption>();
requestCreateOptions.Content = purchaseBasketCreateOption;
requestCreateOptions.Header = new Dictionary <string, string>()
{
{ "Token", $"{token.AccessToken}" }
};
requestCreateOptions.UserAgent = "zoonga.com (http://www.zoonga.com/)";
IHttpResponse httpResponse = await HttpWebRequestProviders <PurchaseBasketCreateOption> .PostBearerWebRequestProvider(string.Format(Urls.PurchaseBasket, purchaseBasketCreateOption.BasketID), requestCreateOptions).ConfigureAwait(false);
if (!string.IsNullOrWhiteSpace(httpResponse.Response))
{
BasketResponse basket = Mapper <BasketResponse> .MapJsonStringToObject(httpResponse.Response);
return(GetResponse(true, basket));
}
else
{
_logger.Log(LogCategory.Error, new Exception("Failed to purchase basket", httpResponse.WebException));
}
return(GetResponse(false, null));
}
public BotUserCredential(IAuthorizationCodeFlow flow, User user, TokenResponse token) : base(flow, user.Id.ToString(), token)
{
From = user;
}
public static async Task MainAsync()
{
var idServerBase = "https://localhost:5001";
var apiBase = "https://localhost:5011";
var disco = await DiscoveryClient.GetAsync(idServerBase);
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
TokenResponse tokenResponse = null;
//Reason to use password grant vs client credentials: for password grant The access token will now contain a sub claim which uniquely identifies the user.
//This “sub” claim can be seen by examining the content variable after the call to the API and also will be displayed on the screen by the console application.
//The presence(or absence) of the sub claim lets the API distinguish between calls on behalf of clients and calls on behalf of users.
Console.WriteLine("Client Credentials (c) or User Login (u)?");
var grantType = Console.ReadLine();
switch (grantType)
{
case "c":
{
var tokenClient = new TokenClient(disco.TokenEndpoint, "client", "clientcredentials");
tokenResponse = await tokenClient.RequestClientCredentialsAsync("petstore");
break;
}
case "u":
{
var tokenClient = new TokenClient(disco.TokenEndpoint, "ro.client", "resourceowner");
Console.Write("Enter username:"******"Enter password:"******"petstore");
break;
}
default:
{
Console.WriteLine("Unrecognized option selection. Type either \"c\" or \"u\".");
break;
}
}
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse);
return;
}
Console.WriteLine(tokenResponse.Json + "\n\n");
var client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
var response = await client.GetAsync(apiBase + "/api/identity");
if (!response.IsSuccessStatusCode)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(response.StatusCode);
Console.ReadKey();
}
else
{
Console.ForegroundColor = ConsoleColor.Green;
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
Console.ReadKey();
}
}
public TokenResult(TokenResponse response)
{
_response = response;
}
private async void cmdLogin()
{
if (String.IsNullOrEmpty(Email))
{
return;
}
IsRunning = true;
IsEnabled = false;
var conexion = this.apiService.CheckConnection();
if (!conexion.IsSuccess)
{
this.IsRunning = false;
this.IsEnabled = true;
await Application.Current.MainPage.DisplayAlert(
"ERROR",
conexion.Message,
"Accept");
return;
}
TokenResponse token = await this.apiService.GetToken(
"https://productosi220.azurewebsites.net",
this.Email,
this.Password);
if (token == null)
{
this.IsRunning = false;
this.IsEnabled = true;
await Application.Current.MainPage.DisplayAlert(
"ERROR",
"Something was wrong, please try later.",
"Accept");
return;
}
if (string.IsNullOrEmpty(token.AccessToken))
{
this.IsRunning = false;
this.IsEnabled = true;
await Application.Current.MainPage.DisplayAlert(
"ERROR",
token.ErrorDescription,
"Accept");
this.Password = String.Empty;
return;
}
MainViewModel mainViewModel = MainViewModel.GetInstance();
mainViewModel.Token = token.AccessToken;
mainViewModel.TokenType = token.TokenType;
Application.Current.MainPage = new NavigationPage(new Notepage());
IsRunning = false;
IsEnabled = true;
}
private static async Task <TResponse> PostAsync <TRequest, TResponse>(Uri url, TokenResponse token, TRequest request)
{
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", token.access_token);
var httpResponse = await httpClient.PostAsJsonAsync(url.ToString(), request);
if (httpResponse.IsSuccessStatusCode)
{
return(await httpResponse.Content.ReadAsAsync <TResponse>());
}
var content = await httpResponse.Content.ReadAsStringAsync();
throw new Exception(content);
}
}
/// <summary>Constructs a new credential instance.</summary>
/// <param name="flow">Authorization code flow.</param>
/// <param name="userId">User identifier.</param>
/// <param name="token">An initial token for the user.</param>
public UserCredential(IAuthorizationCodeFlow flow, string userId, TokenResponse token)
{
this.flow = flow;
this.userId = userId;
this.token = token;
}
public virtual IODataClient BuildODataClient(Action <HttpRequestMessage> beforeRequest = null,
Action <HttpResponseMessage> afterResponse = null, TokenResponse token = null, string odataRouteName = "Test")
{
ODataClient client = new ODataClient(new ODataClientSettings(new Uri($"{Uri}odata/{odataRouteName}/"))
{
BeforeRequest = message =>
{
if (token != null)
{
message.Headers.Add("Authorization",
$"{token.TokenType} {token.AccessToken}");
}
beforeRequest?.Invoke(message);
},
AfterResponse = message =>
{
afterResponse?.Invoke(message);
},
OnCreateMessageHandler = GetHttpMessageHandler
});
return(client);
}
public Task <OidcUserSession> CreateSessionAsync(DateTimeOffset validUntil, ClaimsPrincipal claimsPrincipal, TokenResponse tokenResponse, string sessionState, OpenidConnectPkceState openidClientPkceState)
{
return(CreateUpdateSessionAsync(validUntil, claimsPrincipal, tokenResponse, sessionState, openidClientPkceState.OidcDiscoveryUri, openidClientPkceState.ClientId));
}
public void Logout()
{
tokenResponse = null;
claims = null;
}
public Task <OidcUserSession> UpdateSessionAsync(DateTimeOffset validUntil, ClaimsPrincipal claimsPrincipal, TokenResponse tokenResponse, string sessionState, OidcUserSession userSession)
{
return(CreateUpdateSessionAsync(validUntil, claimsPrincipal, tokenResponse, sessionState, userSession.OidcDiscoveryUri, userSession.ClientId));
}
private Dictionary <string, JsonElement> GetFields(TokenResponse response)
{
return(response.Json.ToObject <Dictionary <string, JsonElement> >());
}
private async Task <OidcUserSession> CreateUpdateSessionAsync(DateTimeOffset validUntil, ClaimsPrincipal claimsPrincipal, TokenResponse tokenResponse, string sessionState, string oidcDiscoveryUri, string clientId)
{
var claimsIdentity = claimsPrincipal.Identities.First();
var claimsList = claimsIdentity.Claims.Select(c => new ClaimValue {
Type = c.Type, Value = c.Value
}).ToList();
var userSession = new OidcUserSession
{
ValidUntil = validUntil,
Claims = claimsList,
AuthenticationType = claimsIdentity.AuthenticationType,
IdToken = tokenResponse.IdToken,
AccessToken = tokenResponse.AccessToken,
RefreshToken = tokenResponse.RefreshToken,
SessionState = sessionState,
OidcDiscoveryUri = oidcDiscoveryUri,
ClientId = clientId
};
await sessionStorage.SetItemAsync(userSessionKey, userSession);
NotifyAuthenticationStateChanged(GetAuthenticationStateAsync());
return(userSession);
}
/// <summary>
/// Converts a JWT token-response endpoint message into a Keycloak identity
/// </summary>
/// <param name="parameters"></param>
/// <param name="message"></param>
/// <returns></returns>
public static Task<KeycloakIdentity> ConvertFromTokenResponseAsync(IKeycloakParameters parameters,
TokenResponse message)
{
if (parameters == null) throw new ArgumentNullException(nameof(parameters));
if (message == null) throw new ArgumentNullException(nameof(message));
return ConvertFromJwtAsync(parameters, message.AccessToken, message.RefreshToken, message.IdToken);
}
/// <summary>Verifies that the token response contains the expected data.</summary>
/// <param name="response">The token response</param>
private void SubtestTokenResponse(TokenResponse response)
{
Assert.That(response.RefreshToken, Is.EqualTo("r"));
Assert.That(response.ExpiresInSeconds, Is.EqualTo(100));
Assert.That(response.Scope, Is.EqualTo("b"));
}
private HttpResponseMessage CreateTokenResponse(GenericXmlSecurityToken token, string scope)
{
var response = new TokenResponse();
if (ConfigurationRepository.AdfsIntegration.PassThruAuthenticationToken)
{
response.AccessToken = token.TokenXml.OuterXml;
response.ExpiresIn = (int)(token.ValidTo.Subtract(DateTime.UtcNow).TotalSeconds);
}
else
{
var bridge = new AdfsBridge(ConfigurationRepository);
response = bridge.ConvertSamlToJwt(token.ToSecurityToken(), scope);
}
return Request.CreateResponse<TokenResponse>(HttpStatusCode.OK, response);
}
public void InvalidateToken()
{
_tokenResponse = null;
}
public ActionResult <SignInResultModel> RefreshToAccess(
[FromForm] string sRefreshToken)
{
//결과용
ApiResultReady rrResult = new ApiResultReady(this);
//엑세스 토큰 갱신용 모델
SignInResultModel rmResult = new SignInResultModel();
rrResult.ResultObject = rmResult;
//API 호출 시간
DateTime dtNow = DateTime.Now;
//리플레시 토큰 갱신 시도 기록
GlobalSign.LogAdd_DB(
1
, ModelDB.UserSignLogType.RefreshToken
, 0
, string.Format("RefreshToAccess 시도 : {0}", sRefreshToken));
//토큰 갱신 요청
TokenResponse tr = GlobalStatic.TokenProc.RefreshTokenAsync(sRefreshToken).Result;
//기존 로그인한 유저 검색
UserSignIn itemUSI = null;
if (true == tr.IsError)
{//토큰 갱신 실패
//DB에 있는 리플레시 토큰은 수동으로 확인해서 갱신해준다.
//토큰 정보는 메모리에 저장되기 때문에 서버가 내려갔다 올라오면 토큰정보가 날아간다.
//이런 예외를 처리하기위해 수동으로 리플레시 토큰을 갱신해야한다.
using (SpaNetCoreFoundationContext db1 = new SpaNetCoreFoundationContext())
{
//기존 로그인한 유저 검색
itemUSI
= db1.UserSignIn
.Where(m => m.RefreshToken == sRefreshToken)
.FirstOrDefault();
if (null == itemUSI)
{//정보 자체가 없다.
rrResult.InfoCode = "-101";
rrResult.Message = "갱신실패 : 인증 정보가 없습니다.";
}
else if (dtNow > itemUSI.RefreshDate)
{//인증정보의 유효기간이 지났다.
rrResult.InfoCode = "-102";
rrResult.Message = "갱신실패 : 인증가능 기간이 지났습니다.";
}
else
{//토큰이 살아있다.
//유저를 검색한다.
User findUser
= db1.User
.Where(w => w.idUser == itemUSI.idUser)
.FirstOrDefault();
//토큰을 갱신한다.
tr
= GlobalStatic.TokenProc
.RequestTokenAsync(findUser.SignEmail, findUser.Password)
.Result;
}
} //end using db1
} //end if (true == tr.IsError)
if (true == rrResult.IsSuccess())
{
if (true == tr.IsError)
{
rrResult.InfoCode = "1";
rrResult.Message = "토큰 갱신에 실패하였습니다.";
}
}
if (true == rrResult.IsSuccess())
{//에러가 없다.
//유저 정보를 받는다.
UserInfoResponse inrUser
= GlobalStatic.TokenProc.UserInfoAsync(tr.AccessToken).Result;
//유저 정보 추출
ClaimModel cm = new ClaimModel(inrUser.Claims);
using (SpaNetCoreFoundationContext db1 = new SpaNetCoreFoundationContext())
{
//기존 로그인한 유저 검색
itemUSI
= db1.UserSignIn
.Where(m => m.idUser == cm.id_int)
.FirstOrDefault();
if (null == itemUSI)
{//기존 로그인 정보가 없다,
//이러면 강제로 토큰이 상실된 것일 수 있다.
rrResult.InfoCode = "1";
rrResult.Message = "토큰 갱신에 실패하였습니다.";
}
else
{
//로그인 되어있는 유저정보 수정
itemUSI.RefreshToken = tr.RefreshToken;
itemUSI.RefreshDate = dtNow.AddDays(30);
//db 적용
db1.SaveChanges();
//유저에게 전달할 정보 만들기
rmResult.idUser = cm.id_int;
rmResult.Email = cm.email;
rmResult.ViewName = rmResult.Email;
rmResult.access_token = tr.AccessToken;
rmResult.refresh_token = tr.RefreshToken;
//기록
GlobalSign.LogAdd_DB(
1
, ModelDB.UserSignLogType.RefreshToken
, cm.id_int
, string.Format("RefreshToAccess 성공 : {0}", rmResult.Email));
}
}//end using db1
}
return(rrResult.ToResult(rmResult));
}
public UserManager(TokenResponse token) : this()
{
this.token = token;
}
/// <summary>
/// Creates an AuthToken from a TokenResponse.
/// </summary>
/// <param name="response">The response.</param>
/// <returns>An AuthToken</returns>
internal static AuthToken FromTokenResponse(TokenResponse response)
{
if (response != null)
{
return new AuthToken
{
AccessToken = response.AccessToken,
ExpiresUtc = response.ExpiresUtc,
RefreshToken = response.RefreshToken,
Territory = response.Territory,
UserId = response.UserId
};
}
else
{
return null;
}
}
/// <summary>
/// Parses the ExtraData collection
/// </summary>
private string ParseExtraData(TokenResponse<AccessToken> result, string key)
{
if (!result.ExtraData.Contains(key))
return null;
var data = result.ExtraData[key];
if (data == null)
return null;
else
return Uri.UnescapeDataString(data.FirstOrDefault());
}
public static HttpResponseMessage CreateTokenResponse(this HttpRequestMessage request, TokenResponse response)
{
Tracing.Information("Returning token response.");
return request.CreateResponse(HttpStatusCode.OK, response);
}
public async Task GetAll_ReturnUsersOrderedProduct()
{
var userOrderedProducts = await _unitOfWork.Orders.FindAsync(c => c.User.UserName == "user");
var client = new RestClient("http://localhost:55258/");
var request = new RestRequest("api/order/", Method.GET);
var token = new TokenResponse("user", "123456");
request.AddHeader("Authorization", token.TokenType + " " + token.AccessToken);
var orderedProducts = client.Execute<List<Product>>(request) as RestResponse<List<Product>>;
Assert.IsNotNull(orderedProducts);
Assert.AreEqual(userOrderedProducts.Count(), orderedProducts.Data.Count);
}