public void StartFlow(string responseType, string scope)
{
// create URI to auth endpoint
var authorizeRequest =
new AuthorizeRequest("https://xamarinoidcsamplests.azurewebsites.net/identity/connect/authorize");
// note: change URI to wherever you deployed your STS (CTRL-SHIFT-F is your friend :)).
// For use with IIS Express, check https://www.github.com/KevinDockx/XamarinFormsOIDCSample.
// dictionary with values for the authorize request
var dic = new Dictionary <string, string>();
dic.Add("client_id", "xamarinsampleimplicit");
dic.Add("response_type", responseType);
dic.Add("scope", scope);
dic.Add("redirect_uri", "https://xamarin-oidc-sample/redirect");
dic.Add("nonce", Guid.NewGuid().ToString("N"));
// add CSRF token to protect against cross-site request forgery attacks.
_currentCSRFToken = Guid.NewGuid().ToString("N");
dic.Add("state", _currentCSRFToken);
var authorizeUri = authorizeRequest.Create(dic);
// or use CreateAuthorizeUrl, passing in the values we defined in the dictionary.
// authorizeRequest.CreateAuthorizeUrl("xamarinsampleimplicit", ...);
wvLogin.Source = authorizeUri;
wvLogin.IsVisible = true;
}
public AuthorizeResponse Authorize([FromBody]
AuthorizeRequest authorizeRequest)
{
try
{
var value = RsaHelper
.DecryptString(authorizeRequest.EncryptedToken,
_asymmetricEncryptionSettings.PublicKey,
false, true);
var token = _tokenService.GetTokenByTypeAndValue(AccessTokenType, value);
var claims = new List <Claim>
{
new Claim("sub", token.Author)
};
var identity = new ClaimsIdentity(JwtBearerDefaults.AuthenticationScheme);
identity.AddClaims(claims);
HttpContext.User = new ClaimsPrincipal(identity);
_tokenService.Delete(token.Id);
return(new AuthorizeResponse());
}
catch (Exception ex)
{
return(new AuthorizeResponse
{
Success = false,
Message = ex.Message
});
}
}
/// <summary>
/// Returns a link to a login page location.
/// HTTP Method: post
/// Endpoint: /restapi/oauth/authorize
/// </summary>
public async Task <string> Post(AuthorizeRequest authorizeRequest, RestRequestConfig restRequestConfig = null)
{
var dict = new Dictionary <string, string>();
Utils.GetPairs(authorizeRequest).ToList().ForEach(t => dict.Add(t.name, t.value.ToString()));
return(await rc.Post <string>(Path(), new FormUrlEncodedContent(dict), null, restRequestConfig));
}
public string CreateAuthorizeUrl(
string clientId,
string responseType,
string scope = null,
string redirectUri = null,
string state = null,
string nonce = null,
string loginHint = null,
string acrValues = null,
string responseMode = null,
string codeChallenge = null,
string codeChallengeMethod = null,
object extra = null)
{
var url = new AuthorizeRequest(AuthorizeEndpoint).CreateAuthorizeUrl(
clientId: clientId,
responseType: responseType,
scope: scope,
redirectUri: redirectUri,
state: state,
nonce: nonce,
loginHint: loginHint,
acrValues: acrValues,
responseMode: responseMode,
codeChallenge: codeChallenge,
codeChallengeMethod: codeChallengeMethod,
extra: extra);
return(url);
}
public static BPWXmlRequest <AuthorizeRequestXML> MapAuthorizeRequest(AuthorizeRequest authorize, string shopId)
{
var requestData = new AuthorizeRequestXML();
requestData.AccountingMode = authorize.AccountingMode;
requestData.Acquirer = authorize.Acquirer;
requestData.Amount = authorize.Amount;
requestData.Antifraud = authorize.AntiFraud;
requestData.CreatePanAlias = authorize.CreatePanAlias;
requestData.Currency = authorize.Currency;
requestData.CVV2 = authorize.CVV2;
requestData.EmailCH = authorize.EmailCh;
requestData.ExpDate = authorize.ExpDate;
requestData.Exponent = authorize.Exponent;
requestData.IpAddress = authorize.IpAddress;
requestData.Name = authorize.Name;
requestData.Network = authorize.Network;
requestData.OpDescr = authorize.OpDescr;
requestData.Options = authorize.Options;
requestData.OrderID = authorize.OrderId;
requestData.PAN = authorize.Pan;
requestData.ProductRef = authorize.ProductRef;
requestData.Surname = authorize.Surname;
requestData.TaxID = authorize.TaxId;
requestData.Userid = authorize.UserId;
requestData.UsrAuthFlag = authorize.UsrAuthFlag;
var request = new BPWXmlRequest <AuthorizeRequestXML>(requestData);
request.SetHeaderInfo(shopId, authorize.OperatorID);
return(request);
}
protected async Task <string> DefaultGetAuthorizationCode(string authorizationEndpoint)
{
CurrentStateToken = GenerateAuthorizationStateToken();
var request = new AuthorizeRequest(authorizationEndpoint);
var authorizeUri = request.CreateAuthorizeUrl(ClientId, OidcConstants.ResponseTypes.Code, Scope, RedirectUriRoot, CurrentStateToken);
var redirectUri = await AuthUriAcquirer.GetAuthorizationUriAsync(authorizeUri, RedirectUriRoot);
if (string.IsNullOrEmpty(redirectUri))
{
return(null);
}
var returnedStateToken = StateCodeRegex.Match(redirectUri).Groups[1].Value;
if (returnedStateToken != CurrentStateToken)
{
return(null);
}
var authCode = AuthCodeRegex.Match(redirectUri).Groups[1].Value;
authCode = WebUtility.UrlDecode(authCode);
return(authCode);
}
public void UsesContextFromFirstMembership()
{
var validator = new AuthorizeRequestValidator();
var app = _testConfig.FindApplication("test");
var request = new AuthorizeRequest
{
client_id = "implicitclient",
response_type = "token",
scope = "membership",
redirect_uri = "https://test2.local",
context = ""
};
var memberships = new List <IdentityMembership>();
memberships.Add(new IdentityMembership()
{
IsPrimaryMember = false, MembershipID = 11234
});
memberships.Add(new IdentityMembership()
{
IsPrimaryMember = false, MembershipID = 6578
});
var result = validator.Validate(app, memberships, request);
Assert.AreEqual("11234", result.context);
Assert.IsFalse(result.HasClaimedMembership);
}
private string GenerarTokenJWT(AuthorizeRequest usuarioInfo)
{
var _symmetricSecurityKey = new SymmetricSecurityKey(
Encoding.UTF8.GetBytes(configuration["JWT:JWT_SECRET_KEY"])
);
var _signingCredentials = new SigningCredentials(
_symmetricSecurityKey, SecurityAlgorithms.HmacSha256
);
var _Header = new JwtHeader(_signingCredentials);
var _Claims = new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.NameId, usuarioInfo.Username.ToString()),
new Claim("nombre", usuarioInfo.Username),
};
var _Payload = new JwtPayload(
issuer: configuration["JWT:JWT_ISSUER_TOKEN"],
audience: configuration["JWT:JWT_AUDIENCE_TOKEN"],
claims: _Claims,
notBefore: DateTime.UtcNow,
// Expira a la 365 dias.
expires: DateTime.UtcNow.AddDays(Convert.ToInt32(configuration["JWT:JWT_EXPIRE_MINUTES"]))
);
var _Token = new JwtSecurityToken(
_Header,
_Payload
);
return(new JwtSecurityTokenHandler().WriteToken(_Token));
}
public AuthorizeResponse Authorize(AuthorizeRequest authorizeRequest)
{
PaymentIntent paymentIntent = _adaptee.Authorize(authorizeRequest.Amount,
authorizeRequest.IsHold,
authorizeRequest.Email,
authorizeRequest.OrdersNumber,
authorizeRequest.FirstName,
authorizeRequest.LastName,
authorizeRequest.DescriptionPayment,
authorizeRequest.PaymentMethod,
authorizeRequest.MerchantId,
authorizeRequest.TransactionIds,
authorizeRequest.UserId,
authorizeRequest.OrderId,
authorizeRequest.TransactionId,
authorizeRequest.CorrelationId);
return(new AuthorizeResponse()
{
Status = paymentIntent.Status,
PaymentId = paymentIntent.Id,
PaymentDate = paymentIntent.Created,
PaymentCardId = paymentIntent.PaymentMethodId,
PaymentFee = paymentIntent.ApplicationFeeAmount
});
}
private AuthorizeResponse AuthorizePayment(
AmazonPaySettings settings,
AmazonPayCheckoutState state,
Store store,
ProcessPaymentRequest request,
Client client,
bool synchronously,
out AuthorizeRequest authRequest)
{
authRequest = new AuthorizeRequest()
.WithMerchantId(settings.SellerId)
.WithAmazonOrderReferenceId(state.OrderReferenceId)
.WithAuthorizationReferenceId(GetRandomId("Authorize"))
.WithCaptureNow(settings.TransactionType == AmazonPayTransactionType.AuthorizeAndCapture)
.WithCurrencyCode(ConvertCurrency(store.PrimaryStoreCurrency.CurrencyCode))
.WithAmount(request.OrderTotal);
if (synchronously)
{
authRequest = authRequest.WithTransactionTimeout(0);
}
// See https://pay.amazon.com/de/developer/documentation/lpwa/201956480
//{"SandboxSimulation": {"State":"Declined", "ReasonCode":"InvalidPaymentMethod", "PaymentMethodUpdateTimeInMins":5}}
//{"SandboxSimulation": {"State":"Declined", "ReasonCode":"AmazonRejected"}}
//if (settings.UseSandbox)
//{
// var authNote = _services.Settings.GetSettingByKey<string>("SmartStore.AmazonPay.SellerAuthorizationNote");
// authRequest = authRequest.WithSellerAuthorizationNote(authNote);
//}
var authResponse = client.Authorize(authRequest);
return(authResponse);
}
private async void btnOidcTokenHybrid_Click(object sender, EventArgs e)
{
var request = new AuthorizeRequest(Preferences.AuthorizationEndpoint);
var url = request.CreateAuthorizeUrl(
clientId: txtOidcClientIdHybrid.Text,
responseType: OidcConstants.ResponseTypes.CodeIdTokenToken,
responseMode: OidcConstants.ResponseModes.FormPost,
scope: txtOidcScopesHybrid.Text,
redirectUri: txtOidcRedirectUriHybrid.Text,
state: CryptoRandom.CreateUniqueId(),
nonce: CryptoRandom.CreateUniqueId());
LaunchBrowser(url);
Tuple <string, string, string> tuple = await GetResponseFromAuthorizationServer(txtOidcRedirectUriHybrid.Text + "/", "hybrid");
txtOidcCodeHybrid.Text = tuple.Item1;
txtOidcIdTokenHybrid.Text = tuple.Item2;
txtOidcIdTokenHybridParsed.Text = ParseJwt(tuple.Item2);
txtOidcAccessTokenHybrid.Text = tuple.Item3;
txtOidcAccessTokenHybridParsed.Text = ParseJwt(tuple.Item3);
lastAccessToken = txtOidcAccessTokenHybrid.Text;
btnOidcGetProfileHybrid.Enabled = true;
}
/// <summary>
/// Authorizes a user, by email, to have access to a collection
/// </summary>
/// <param name="collectionName">Name of the collection to grant permission</param>
/// <param name="userEmail">Email of the user to grant permission to</param>
/// <param name="permission">Which permission to assign</param>
/// <returns>True if succesfull</returns>
public async Task <bool> AuthorizeUser(string collectionName, string userEmail, CollectionPermission permission)
{
AuthorizeRequest requestBody = new AuthorizeRequest(APIKey, collectionName, userEmail, permission);
HttpResponseMessage response = null;
try
{
response = await Client.PostAsync(Endpoints.AuthorizeUser, IndicoCustomRequest.StringContentFromObject(requestBody));
HTTPMagic.CheckStatus(response);
string responseBody = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <SimpleResponse>(responseBody).Results);
}
catch (HttpRequestException hre)
{
throw new IndicoAPIException(Resources.Application_API_Request_Failure, hre);
}
finally
{
if (response != null)
{
response.Dispose();
}
}
}
//AUTHENTICATION FLOW
public static string SpotifyAuthorization(AuthorizeRequest authorizeRequest)
{
string scopes = "";
authorizeRequest.Scope.ForEach(s => scopes += s + "%20");
return($"{root}/authorize?client_id={authorizeRequest.Client_Id}&response_type=code&redirect_uri={authorizeRequest.Redirect_IUri}&scope={scopes}&state={authorizeRequest.State}");
}
public void UsesContextThatIsPrimaryIfNoneInRequest()
{
var validator = new AuthorizeRequestValidator();
var app = _testConfig.FindApplication("test");
var request = new AuthorizeRequest
{
client_id = "implicitclient",
response_type = "token",
scope = "membership",
redirect_uri = "https://test2.local",
context = ""
};
var memberships = new List <IdentityMembership>();
memberships.Add(new IdentityMembership()
{
CanAccessNeeds = true, MembershipID = 11234
});
memberships.Add(new IdentityMembership()
{
IsPrimaryMember = true, MembershipID = 6578
});
var result = validator.Validate(app, memberships, request);
Assert.AreEqual("6578", result.context);
}
public async Task <IHttpActionResult> Authorize(AuthorizeRequest request)
{
if (request != null)
{
using (var scope = DependencyConfig.Container.BeginLifetimeScope())
{
var service = scope.Resolve <IWalletService>();
var user = await service.Authorize(request.Username, request.Password);
if (user != null)
{
return(Ok(new AuthorizeResponse {
User = user
}));
}
else
{
return(Content(HttpStatusCode.BadRequest, new { ErrorMessage = "Please, verify your username/password." }));
}
}
}
else
{
return(BadRequest());
}
}
public void AuthorizeApiCall()
{
string uniqueReferenceId = GenerateRandomUniqueString();
AuthorizeRequest authRequestParameters = new AuthorizeRequest();
authRequestParameters.WithAmazonOrderReferenceId(Session["amazonOrderReferenceId"].ToString())
.WithAmount(decimal.Parse(Session["amount"].ToString()))
.WithCurrencyCode(Regions.currencyCode.USD)
.WithAuthorizationReferenceId(uniqueReferenceId)
.WithTransactionTimeout(0)
.WithCaptureNow(true)
.WithSellerAuthorizationNote("Note");
AuthorizeResponse authResponse = client.Authorize(authRequestParameters);
// Authorize was not a success Get the Error code and the Error message
if (!authResponse.GetSuccess())
{
string errorCode = authResponse.GetErrorCode();
string errorMessage = authResponse.GetErrorMessage();
authorize.InnerHtml = authResponse.GetJson();
}
else
{
amazonAuthorizationId = authResponse.GetAuthorizationId();
captureNow = authResponse.GetCaptureNow();
// If captureNow was true then the capture has already happened. save the capture id(s).
if (captureNow)
{
amazonCaptureIdList = authResponse.GetCaptureIdList();
}
authorize.InnerHtml = authResponse.GetJson();
}
}
public async Task CallBack(string code)
{
if (string.IsNullOrEmpty(code))
{
var state = CryptoRandom.CreateRandomKeyString(64);
var nonce = CryptoRandom.CreateRandomKeyString(64);
var request = new AuthorizeRequest(Configuration.AuthorizeEndpoint);
var url = request.CreateAuthorizeUrl(
clientId: "padmate_AuthorizationCode",
responseType: "code",
scope: "dpcontrolapiscope",
redirectUri: Configuration.CodeCallBackUrl,
state: state,
nonce: nonce);
Process.Start(url);
}
else
{
var client = new TokenClient(
Configuration.TokenEndpoint,
"padmate_AuthorizationCode",
"padmate_authorizationcode_secret");
var response = await client.RequestAuthorizationCodeAsync(code, Configuration.CodeCallBackUrl);
await this.CallApi(response.AccessToken);
}
}
public async Task <AuthorizeResponse> Authenticate(AuthorizeRequest request)
{
if (string.IsNullOrEmpty(request.LoginId))
{
throw new Exception();
}
var myContent = JsonConvert.SerializeObject(request);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var builder = new UriBuilder(new Uri(string.Format(AuthorizeUrl, CustomerId)));
HttpRequestMessage requests = new HttpRequestMessage(HttpMethod.Post, builder.Uri);
requests.Content = new StringContent(myContent, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.SendAsync(requests);
if (response.StatusCode == HttpStatusCode.BadRequest)
{
throw new Exception();
}
if (response.EnsureSuccessStatusCode().IsSuccessStatusCode)
{
var res = await response.Content.ReadAsAsync <AuthorizeResponse>();
return(res);
}
throw new Exception();
}
/// <summary>
/// Successful response returned from a Credit Card Present Authorization Only request.
/// https://apidocs.securenet.com/docs/creditcardpresent.html?lang=JSON#authonly
/// </summary>
public int Credit_Card_Present_AuthorizationOnly_Request_Returns_Successfully()
{
// Arrange
var request = new AuthorizeRequest
{
Amount = 11.00m,
Card = new Card
{
TrackData = "%B4444333322221111^SECURENET^16041015432112345678?;4444333322221111=16041015432112345678?",
},
DeveloperApplication = new DeveloperApplication
{
DeveloperId = 12345678,
Version = "1.2"
}
};
var apiContext = new APIContext();
var controller = new PaymentsController();
// Act
var response = controller.ProcessRequest <AuthorizeResponse>(apiContext, request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Transaction);
Assert.IsTrue(response.Transaction.TransactionId > 0);
return(response.Transaction.TransactionId);
}
public static void RunRealWorldExample()
{
Authorizer releasedClientAuthorizer = new ReleasedClientAuthorizer();
Authorizer releasedContractorAuthorizer = new ReleasedContractorAuthorizer();
//a1.SetSuccessor(a2);
releasedContractorAuthorizer.SetSuccessor(releasedClientAuthorizer);
AuthorizeRequest releaseClientRequest = new AuthorizeRequest
{
AuthorizeType = AuthorizeTypes.ReleasedClient,
OrganizationName = "ReleasedClientOrgName"
};
releasedContractorAuthorizer.HandleAuthorization(releaseClientRequest);
AuthorizeRequest releaseContractorRequest = new AuthorizeRequest
{
AuthorizeType = AuthorizeTypes.ReleasedContractor,
OrganizationName = "ReleasedContractorOrgName"
};
releasedContractorAuthorizer.HandleAuthorization(releaseContractorRequest);
}
public void StartFlow(string responseType, string scope)
{
// create URI to authorize endpoint - use WebHost or SelfHost from the
// samples solution.
var authorizeRequest =
new AuthorizeRequest("https://localhost:44333/core/connect/authorize");
// dictionary with values for the authorize request
var dic = new Dictionary <string, string>();
dic.Add("client_id", "implicitclient");
dic.Add("response_type", responseType);
dic.Add("scope", scope);
dic.Add("redirect_uri", "https://xamarin-oidc-sample/redirect");
dic.Add("nonce", Guid.NewGuid().ToString("N"));
// add CSRF token to protect against cross-site request forgery attacks.
_currentCSRFToken = Guid.NewGuid().ToString("N");
dic.Add("state", _currentCSRFToken);
var authorizeUri = authorizeRequest.Create(dic);
// or use CreateAuthorizeUrl, passing in the values we defined in the dictionary.
// authorizeRequest.CreateAuthorizeUrl("implicitclient", ...);
wvLogin.Source = authorizeUri;
wvLogin.IsVisible = true;
}
public Task <AuthorizeResponse> AuthorizeAmountAsync(AuthorizeRequest authRequest)
{
var request = new RestRequest(Urls.TransactionsApiV1Authorize, Method.POST);
request.AddJsonBody(authRequest);
return(MakeRestRequest <AuthorizeResponse>(request));
}
public string CreateAuthorizationRequest()
{
// Create URI to authorization endpoint
var authorizeRequest = new AuthorizeRequest(GlobalSetting.Instance.IdentityEndpoint);
// Dictionary with values for the authorize request
var dic = new Dictionary <string, string>();
dic.Add("client_id", GlobalSetting.Instance.ClientId);
dic.Add("client_secret", GlobalSetting.Instance.ClientSecret);
dic.Add("response_type", "code id_token");
dic.Add("scope", "openid profile basket orders locations marketing offline_access");
dic.Add("redirect_uri", GlobalSetting.Instance.IdentityCallback);
dic.Add("nonce", Guid.NewGuid().ToString("N"));
dic.Add("code_challenge", CreateCodeChallenge());
dic.Add("code_challenge_method", "S256");
// Add CSRF token to protect against cross-site request forgery attacks.
var currentCSRFToken = Guid.NewGuid().ToString("N");
dic.Add("state", currentCSRFToken);
var authorizeUri = authorizeRequest.Create(dic);
return(authorizeUri);
}
public string Authorize(AuthorizeRequest authRequest)
{
var uniqueId = _uniqueIdGenerator.GetUniqueId();
_authLookup.Add(uniqueId, new Authorization(authRequest.CardNumber, authRequest.Currency, authRequest.Amount));
return(uniqueId);
}
/// <summary>Asynchronous as long as we do not set TransactionTimeout to 0. So transaction is always in pending state after return.</summary>
public void Authorize(AmazonPayClient client, ProcessPaymentResult result, List<string> errors, string orderReferenceId, decimal orderTotalAmount, string currencyCode, string orderGuid)
{
var request = new AuthorizeRequest();
request.SellerId = client.Settings.SellerId;
request.AmazonOrderReferenceId = orderReferenceId;
request.AuthorizationReferenceId = GetRandomId("Authorize");
request.CaptureNow = (client.Settings.TransactionType == AmazonPayTransactionType.AuthorizeAndCapture);
//request.SellerAuthorizationNote = client.Settings.SellerNoteAuthorization.Truncate(256);
request.AuthorizationAmount = new Price()
{
Amount = orderTotalAmount.ToString("0.00", CultureInfo.InvariantCulture),
CurrencyCode = currencyCode ?? "EUR"
};
var response = client.Service.Authorize(request);
if (response != null && response.IsSetAuthorizeResult() && response.AuthorizeResult.IsSetAuthorizationDetails())
{
var details = response.AuthorizeResult.AuthorizationDetails;
result.AuthorizationTransactionId = details.AmazonAuthorizationId;
result.AuthorizationTransactionCode = details.AuthorizationReferenceId;
if (details.IsSetAuthorizationStatus())
{
var status = details.AuthorizationStatus;
if (status.IsSetState())
{
result.AuthorizationTransactionResult = status.State.ToString();
}
if (request.CaptureNow && details.IsSetIdList() && details.IdList.IsSetmember() && details.IdList.member.Count() > 0)
{
result.CaptureTransactionId = details.IdList.member[0];
}
if (status.IsSetReasonCode())
{
if (status.ReasonCode.IsCaseInsensitiveEqual("InvalidPaymentMethod") || status.ReasonCode.IsCaseInsensitiveEqual("AmazonRejected") ||
status.ReasonCode.IsCaseInsensitiveEqual("ProcessingFailure") || status.ReasonCode.IsCaseInsensitiveEqual("TransactionTimedOut") ||
status.ReasonCode.IsCaseInsensitiveEqual("TransactionTimeout"))
{
if (status.IsSetReasonDescription())
errors.Add("{0}: {1}".FormatWith(status.ReasonCode, status.ReasonDescription));
else
errors.Add(status.ReasonCode);
}
}
}
}
// The response to the Authorize call includes the AuthorizationStatus response element, which will be always be
// set to Pending if you have selected the asynchronous mode of operation.
result.NewPaymentStatus = Core.Domain.Payments.PaymentStatus.Pending;
}
static async Task Main(string[] args)
{
var socket = new System.Net.WebSockets.ClientWebSocket();
var chargerId = "xxxx"; // id of the charger
var password = "******"; // any non-empty string
var endpoint = "xxxxxx"; //url to websocket server e.g ws://abc.com
var auth = Convert.ToBase64String(Encoding.UTF8.GetBytes(chargerId + ":" + password));
socket.Options.SetRequestHeader("Authorization", "Basic " + auth);
socket.Options.AddSubProtocol("ocpp1.6");
var cancellationToken = CancellationToken.None;
try
{
await socket.ConnectAsync(new Uri(endpoint + "/" + chargerId), cancellationToken);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
Console.WriteLine(socket.State); // status is opened now
var sampleAuthReq = new AuthorizeRequest();
sampleAuthReq.IdTag = "111"; // a correct IdTag predefined on server side
var newMessageToSend = new TransportLayerMessage
{
MessageType = MessageTypes.CALL,
UniqueId = GenerateUniqueId(),
Action = sampleAuthReq.Action,
Payload = sampleAuthReq.ToJson()
};
if (socket.State == System.Net.WebSockets.WebSocketState.Open)
{
try
{
var keystring = Console.ReadKey();
while (keystring.Key == ConsoleKey.S)
{
await Send(newMessageToSend.ToJson(), socket, cancellationToken);
keystring = Console.ReadKey();
}
Console.WriteLine("finished");
Console.ReadKey();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
public void Authorize(AuthorizeRequest request)
{
if (!request.Id.HasValue)
{
throw new ArgumentNullException(nameof(request.Id));
}
this._requestTable.Add(request.Id.Value.ToString(), request);
this.Send(request);
}
public void Authorize(AuthorizeRequest clientRequest)
{
ClientRequest = clientRequest;
if (!typeof(Csla.Core.ICommandObject).IsAssignableFrom(clientRequest.ObjectType))
{
throw new SecurityException("Authorization Failed");
}
}
protected Uri GetAuthenticationUri()
{
var authRequest = new AuthorizeRequest(Configuration.AuthorizeUri);
var redirectUri = GetRedirectUri().AbsoluteUri;
var authUrl = authRequest.CreateAuthorizeUrl(Constants.Authentication.ClientId,
Constants.Authentication.ResponseType, Constants.Authentication.Scope,
redirectUri, nonce: GenerateNOnce());
return(new Uri(authUrl));
}
public ActionResult <AuthenticateSpotify> Get() //USED TO RETURN LINK FOR CONVALIDATION SPOTIFY
{
string guidString = Convert.ToBase64String(Guid.NewGuid().ToByteArray());
AuthorizeRequest authorizeRequest = new AuthorizeRequest(ClientId, "code", SpotifyAccessRedirectEndpoint(), guidString, Scope);
var response = new AuthenticateSpotify()
{
Url = SpotifyAuthorization(authorizeRequest)
};
return(response);
}
public async Task AuthorizeAndCapture_Test()
{
var authorization = new AuthorizeRequest
{
Amount = new Amount
{
BaseAmount = 1000
},
Card = new Card
{
CardPresent = false,
Cvv = "123",
ExpirationMonth = "12",
ExpirationYear = "21",
Pan = "5105105105105100"
},
Mid = _merchantId,
Terminal = new Terminal
{
EntryType = EntryType.Keypad,
TerminalId = _terminalId,
TerminalType = TerminalType.ECommerce
},
Payer = new Payer
{
BillingAddress = new Address
{
PostalCode = "76132"
}
},
Order = new Order
{
OrderNumber = "testing"
}
};
var response = await _client.AuthorizeAmountAsync(authorization);
var capture = new CaptureRequest
{
TransactionId = response.TransactionId,
Mid = _merchantId,
Terminal = new Terminal
{
EntryType = EntryType.Keypad,
TerminalId = _terminalId,
TerminalType = TerminalType.ECommerce
}
};
var captureResponse = await _client.CaptureAmountAsync(capture);
Assert.IsNotNull(capture.TransactionId);
}
public async Task VoidCompletes_Test()
{
var authorization = new AuthorizeRequest
{
Amount = new Amount
{
BaseAmount = 1000
},
Card = new Card
{
CardPresent = false,
Cvv = "123",
ExpirationMonth = "12",
ExpirationYear = "21",
Pan = "5105105105105100"
},
Mid = _merchantId,
Terminal = new Terminal
{
EntryType = EntryType.Keypad,
TerminalId = _terminalId,
TerminalType = TerminalType.ECommerce
},
Payer = new Payer
{
BillingAddress = new Address
{
PostalCode = "76132"
}
}
};
var response = await _client.AuthorizeAmountAsync(authorization);
Assert.IsNotNull(response.TransactionId);
Assert.IsNotNull(response.AuthCode);
var voidRequest = new VoidRequest
{
Mid = _merchantId,
Terminal = new Terminal
{
EntryType = EntryType.Keypad,
TerminalId = _terminalId,
TerminalType = TerminalType.ECommerce
},
TransactionId = response.TransactionId
};
var voidResponse = await _client.VoidTransactionAsync(voidRequest);
Assert.IsNotNull(voidResponse.TransactionId);
}
public static AuthorizeResponse AuthorizeAction(OffAmazonPaymentsServicePropertyCollection propertiesCollection,
IOffAmazonPaymentsService service, string orderReferenceId, String orderAmount, int indicator, int authorizationOption)
{
//initiate the authorization request
AuthorizeRequest authRequest = new AuthorizeRequest();
authRequest.AmazonOrderReferenceId = orderReferenceId;
authRequest.SellerId = propertiesCollection.MerchantID;
Price price = new Price();
//get the ordertotal object from the setOrderReference's response
OrderTotal authOrderTotal = new OrderTotal();
price.Amount = orderAmount;
price.CurrencyCode = propertiesCollection.CurrencyCode;
authRequest.AuthorizationAmount = price;
authRequest.AuthorizationReferenceId = orderReferenceId.Replace('-', 'a') + "authRef" + indicator.ToString();
//If Fast Authorization is required, set the transaction timeout in the request to 0.
if (authorizationOption == 2)
{
authRequest.TransactionTimeout = 0;
}
return AuthorizeSample.InvokeAuthorize(service, authRequest);
}
public static AuthorizeResponse InvokeAuthorize(IOffAmazonPaymentsService service, AuthorizeRequest request)
{
AuthorizeResponse response = null;
try
{
response = service.Authorize(request);
Console.WriteLine("Service Response");
Console.WriteLine("=============================================================================");
Console.WriteLine();
Console.WriteLine(" AuthorizeResponse");
if (response.IsSetAuthorizeResult())
{
Console.WriteLine(" AuthorizeResult");
AuthorizeResult authorizeResult = response.AuthorizeResult;
if (authorizeResult.IsSetAuthorizationDetails())
{
Console.WriteLine(" AuthorizationDetails");
AuthorizationDetails authorizationDetails = authorizeResult.AuthorizationDetails;
if (authorizationDetails.IsSetAmazonAuthorizationId())
{
Console.WriteLine(" AmazonAuthorizationId");
Console.WriteLine(" {0}", authorizationDetails.AmazonAuthorizationId);
}
if (authorizationDetails.IsSetAuthorizationReferenceId())
{
Console.WriteLine(" AuthorizationReferenceId");
Console.WriteLine(" {0}", authorizationDetails.AuthorizationReferenceId);
}
if (authorizationDetails.IsSetAuthorizationBillingAddress())
{
Console.WriteLine(" AuthorizationBillingAddress");
Address authorizationBillingAddress = authorizationDetails.AuthorizationBillingAddress;
if (authorizationBillingAddress.IsSetName())
{
Console.WriteLine(" Name");
Console.WriteLine(" {0}", authorizationBillingAddress.Name);
}
if (authorizationBillingAddress.IsSetAddressLine1())
{
Console.WriteLine(" AddressLine1");
Console.WriteLine(" {0}", authorizationBillingAddress.AddressLine1);
}
if (authorizationBillingAddress.IsSetAddressLine2())
{
Console.WriteLine(" AddressLine2");
Console.WriteLine(" {0}", authorizationBillingAddress.AddressLine2);
}
if (authorizationBillingAddress.IsSetAddressLine3())
{
Console.WriteLine(" AddressLine3");
Console.WriteLine(" {0}", authorizationBillingAddress.AddressLine3);
}
if (authorizationBillingAddress.IsSetCity())
{
Console.WriteLine(" City");
Console.WriteLine(" {0}", authorizationBillingAddress.City);
}
if (authorizationBillingAddress.IsSetCounty())
{
Console.WriteLine(" County");
Console.WriteLine(" {0}", authorizationBillingAddress.County);
}
if (authorizationBillingAddress.IsSetDistrict())
{
Console.WriteLine(" District");
Console.WriteLine(" {0}", authorizationBillingAddress.District);
}
if (authorizationBillingAddress.IsSetStateOrRegion())
{
Console.WriteLine(" StateOrRegion");
Console.WriteLine(" {0}", authorizationBillingAddress.StateOrRegion);
}
if (authorizationBillingAddress.IsSetPostalCode())
{
Console.WriteLine(" PostalCode");
Console.WriteLine(" {0}", authorizationBillingAddress.PostalCode);
}
if (authorizationBillingAddress.IsSetCountryCode())
{
Console.WriteLine(" CountryCode");
Console.WriteLine(" {0}", authorizationBillingAddress.CountryCode);
}
if (authorizationBillingAddress.IsSetPhone())
{
Console.WriteLine(" Phone");
Console.WriteLine(" {0}", authorizationBillingAddress.Phone);
}
}
if (authorizationDetails.IsSetSellerAuthorizationNote())
{
Console.WriteLine(" SellerAuthorizationNote");
Console.WriteLine(" {0}", authorizationDetails.SellerAuthorizationNote);
}
if (authorizationDetails.IsSetAuthorizationAmount())
{
Console.WriteLine(" AuthorizationAmount");
Price authorizationAmount = authorizationDetails.AuthorizationAmount;
if (authorizationAmount.IsSetAmount())
{
Console.WriteLine(" Amount");
Console.WriteLine(" {0}", authorizationAmount.Amount);
}
if (authorizationAmount.IsSetCurrencyCode())
{
Console.WriteLine(" CurrencyCode");
Console.WriteLine(" {0}", authorizationAmount.CurrencyCode);
}
}
if (authorizationDetails.IsSetCapturedAmount())
{
Console.WriteLine(" CapturedAmount");
Price capturedAmount = authorizationDetails.CapturedAmount;
if (capturedAmount.IsSetAmount())
{
Console.WriteLine(" Amount");
Console.WriteLine(" {0}", capturedAmount.Amount);
}
if (capturedAmount.IsSetCurrencyCode())
{
Console.WriteLine(" CurrencyCode");
Console.WriteLine(" {0}", capturedAmount.CurrencyCode);
}
}
if (authorizationDetails.IsSetAuthorizationFee())
{
Console.WriteLine(" AuthorizationFee");
Price authorizationFee = authorizationDetails.AuthorizationFee;
if (authorizationFee.IsSetAmount())
{
Console.WriteLine(" Amount");
Console.WriteLine(" {0}", authorizationFee.Amount);
}
if (authorizationFee.IsSetCurrencyCode())
{
Console.WriteLine(" CurrencyCode");
Console.WriteLine(" {0}", authorizationFee.CurrencyCode);
}
}
if (authorizationDetails.IsSetCreationTimestamp())
{
Console.WriteLine(" CreationTimestamp");
Console.WriteLine(" {0}", authorizationDetails.CreationTimestamp);
}
if (authorizationDetails.IsSetExpirationTimestamp())
{
Console.WriteLine(" ExpirationTimestamp");
Console.WriteLine(" {0}", authorizationDetails.ExpirationTimestamp);
}
if (authorizationDetails.IsSetAuthorizationStatus())
{
Console.WriteLine(" AuthorizationStatus");
Status authorizationStatus = authorizationDetails.AuthorizationStatus;
if (authorizationStatus.IsSetState())
{
Console.WriteLine(" State");
Console.WriteLine(" {0}", authorizationStatus.State);
}
if (authorizationStatus.IsSetLastUpdateTimestamp())
{
Console.WriteLine(" LastUpdateTimestamp");
Console.WriteLine(" {0}", authorizationStatus.LastUpdateTimestamp);
}
if (authorizationStatus.IsSetReasonCode())
{
Console.WriteLine(" ReasonCode");
Console.WriteLine(" {0}", authorizationStatus.ReasonCode);
}
if (authorizationStatus.IsSetReasonDescription())
{
Console.WriteLine(" ReasonDescription");
Console.WriteLine(" {0}", authorizationStatus.ReasonDescription);
}
}
if (authorizationDetails.IsSetAddressVerificationCode())
{
Console.WriteLine(" AddressVerificationCode");
Console.WriteLine(" {0}", authorizationDetails.AddressVerificationCode);
}
}
}
}
catch (OffAmazonPaymentsServiceException ex)
{
PrintException(ex);
}
return response;
}
