static void Main(string[] args)
{
Brain brain = new Brain();
// brain.doWork();
Thread myBrainThread = new Thread(new ThreadStart(brain.doWork));
myBrainThread.Start();
ConsoleKeyInfo cki = new ConsoleKeyInfo();
do
{
Console.WriteLine("\nPress 'x' key to logout.");
while (Console.KeyAvailable == false)
Thread.Sleep(250); // Loop until input is entered.
cki = Console.ReadKey(true);
// Console.WriteLine("You pressed the '{0}' key.", cki.Key);
} while (cki.Key != ConsoleKey.X);
IPEndPoint registryEP = getEndpoint(ConfigurationManager.AppSettings["registryIP"], ConfigurationManager.AppSettings["registryPort"]);
socket.Connect(registryEP);
LogoutRequest lor = new LogoutRequest();
byte[] logoutRequestMessage = lor.Encode();
socket.Send(logoutRequestMessage, logoutRequestMessage.Length);
Console.WriteLine("You have logged out.");
}
protected void logoutButton_Click(object sender, EventArgs e)
{
try {
// Create a logout request.
LogoutRequest logoutRequest = new LogoutRequest();
logoutRequest.Issuer = new Issuer(CreateAbsoluteURL("~/"));
logoutRequest.NameID = new NameID(Context.User.Identity.Name);
// Serialize the logout request to XML for transmission.
XmlElement logoutRequestXml = logoutRequest.ToXml();
// Send the logout request to the IdP over HTTP redirect.
string logoutURL = WebConfigurationManager.AppSettings["idpLogoutURL"];
X509Certificate2 x509Certificate = (X509Certificate2) Application[Global.SPX509Certificate];
SingleLogoutService.SendLogoutRequestByHTTPRedirect(Response, logoutURL, logoutRequestXml, null, x509Certificate.PrivateKey);
// Logout locally.
FormsAuthentication.SignOut();
Session.Abandon();
}
catch (Exception exception) {
Trace.Write("SP", "Error on logout page", exception);
}
}
public void ValidCommand_IsValid()
{
var input = new LogoutRequest {
SecurityContext = A.Dummy<ISecurityContext>()
};
var actualResult = _sut.Validate(input);
Assert.That(actualResult.IsValid, Is.True);
}
public void NullSecurityContext_IsInvalid()
{
var input = new LogoutRequest {
SecurityContext = null
};
var actualResult = _sut.Validate(input);
Assert.That(actualResult.IsValid, Is.False);
}
public void LogsOutAndRedirects()
{
var service = new Mock<IUserAccountService>();
var endpoint = new LogoutEndpoint(service.Object);
var request = new LogoutRequest();
var continuation = endpoint.Logout(request);
service.Verify(x => x.Logout());
continuation.AssertWasRedirectedTo<HomeRequest>();
}
public ApiResult Logout(LogoutRequest request)
{
var sessionWasValid = SessionRepository.InvalidateSession(request.SessionId);
return(new ApiResult
{
Success = true,
ErrorMessage = (sessionWasValid ? string.Empty : "InvalidSessionId")
});
}
public async Task <bool> LogoutAsync(LogoutRequest model)
{
var user = await userRepository.GetByUserNameAsync(model.OwnerId, model.Username);
var userDto = userToUserDtoHydrator.Hydrate(user);
await cachingService.DestroyUserSession(user.OwnerId, userDto.UserName);
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="Saml20LogoutRequest"/> class.
/// </summary>
public Saml20LogoutRequest()
{
Request = new LogoutRequest
{
Version = Saml20Constants.Version,
Id = "id" + Guid.NewGuid().ToString("N"),
Issuer = new NameId(),
IssueInstant = DateTime.Now
};
}
public Task Logout(LogoutRequest data)
{
var flowId = HttpContext.Items["flowId"].ToString();
var logoutEvent = new LogoutEvent {
Token = data.Token
};
publishingRouter.Publish(Queues.Users, logoutEvent, flowId);
return(Task.CompletedTask);
}
/// <summary>
/// Logout from from the system.
/// </summary>
/// <returns>Success or failure flag.</returns>
public bool Logout()
{
var request = new LogoutRequest().Prepare();
var response = Client.Logout(request);
Correlate(request, response);
return(response.Acknowledge == AcknowledgeType.Success);
}
public OidcRequest CreatePopupRequest(LogoutRequest request)
{
return(HandleErrors(nameof(CreatePopupRequest), () => new OidcRequest
{
Url = request.Url,
Timeout = request.Parameters.OpenPopupTimeout.TotalMilliseconds,
WindowName = request.Parameters.PopupWindowName,
WindowFeatures = request.Parameters.PopupWindowFeatures
}));
}
public async Task <IActionResult> Logout([FromRoute] LogoutRequest request)
{
IActionResult result = null;
Ensure.Guid.IsNotEmpty(request.Application);
result = Factory.CreateSuccessResponse(await Server.Logout(request.Application));
return(result);
}
public async Task <LogoutResponse> Logout(LogoutRequest request)
{
var apiResult = await HttpClient.PostAsJsonAsync("api/Player/Logout", request);
var result = await EnsureApiResult <LogoutResponse>(apiResult);
Token = null;
return(result);
}
public void BuildLoggedOutViewModelAsync_WhenSuccessfulLogout_ShowCorrectLogoutView()
{
//arrange
const string logoutId = "logoutId";
const string iFrameUrl = "iframeUrl";
const string redirectUrl = "redirectUrl";
var user = new ClaimsPrincipal(new ClaimsIdentity(new[]
{
new Claim(ClaimTypes.Name, "name"),
new Claim(JwtClaimTypes.IdentityProvider, "client")
}));
var client = new Client
{
ClientId = "clientId",
ClientName = "clientName",
PostLogoutRedirectUris = new List <string> {
redirectUrl
}
};
var logoutMessge = new LogoutMessage
{
ClientId = client.ClientId,
ClientName = client.ClientName,
ClientIds = new List <string>
{
client.ClientId
},
SessionId = "sessionId",
SubjectId = "subjectId",
PostLogoutRedirectUri = redirectUrl
};
LogoutRequest logoutRequest = new LogoutRequest(iFrameUrl, logoutMessge);
mockInteraction.Setup(x => x.GetLogoutContextAsync(logoutId))
.ReturnsAsync(logoutRequest).Verifiable();
mockAccessor.SetupGet(x => x.HttpContext.User).Returns(user).Verifiable();
//act
var result = CreateSut().BuildLoggedOutViewModelAsync(logoutId).Result;
//assert
Assert.True(result.AutomaticRedirectAfterSignOut);
Assert.Equal(redirectUrl, result.PostLogoutRedirectUri);
Assert.Equal(client.ClientName, result.ClientName);
Assert.Equal(iFrameUrl, result.SignOutIframeUrl);
Assert.Equal(logoutId, result.LogoutId);
mockInteraction.Verify();
mockAccessor.Verify();
}
public async Task <AjaxResult <string> > Logout(LogoutRequest logoutRequest)
{
AjaxResult <string> ajaxResponse = new AjaxResult <string>("退出成功");
HttpClient signOutClient = HttpClientFactory.CreateClient("Identityserver4Client");
if (User?.Identity.IsAuthenticated == true)
{
// delete local authentication cookie
await SignInManager.SignOutAsync();
// raise the logout event
await EventService.RaiseAsync(new UserLogoutSuccessEvent(User.GetSubjectId(), User.GetDisplayName()));
}
await HttpContext.SignOutAsync();
string accessToken = await HttpContext.GetTokenAsync(HybridConsts.LocalApi.AuthenticationScheme, OpenIdConnectParameterNames.AccessToken);
if (!string.IsNullOrWhiteSpace(accessToken))
{
var accessTokenRevocationResponse = await signOutClient.RevokeTokenAsync(new TokenRevocationRequest
{
Address = signOutClient.BaseAddress + "connect/revocation",
ClientId = "mobileAppClient",
ClientSecret = "mobile app secrect",
TokenTypeHint = OpenIdConnectParameterNames.AccessToken,
Token = accessToken
});
if (accessTokenRevocationResponse.IsError)
{
ajaxResponse.Success = false;
ajaxResponse.Content = accessTokenRevocationResponse.Error;
return(ajaxResponse);
}
}
var refreshTokenRevocationResponse = await signOutClient.RevokeTokenAsync(new TokenRevocationRequest
{
Address = signOutClient.BaseAddress + "connect/revocation",
ClientId = "mobileAppClient",
ClientSecret = "mobile app secrect",
TokenTypeHint = OpenIdConnectParameterNames.RefreshToken,
Token = logoutRequest.RefreshToken
});
if (refreshTokenRevocationResponse.IsError)
{
ajaxResponse.Success = false;
ajaxResponse.Error = new ErrorInfo {
Message = refreshTokenRevocationResponse.Error
};
return(ajaxResponse);
}
return(ajaxResponse);
}
/// <summary>
/// Logout from from the system.
/// </summary>
/// <returns>Success or failure flag.</returns>
public bool Logout()
{
LogoutRequest request = new LogoutRequest();
request.RequestId = NewRequestId;
request.ClientTag = ClientTag;
request.AccessToken = AccessToken;
LogoutResponse response = ActionServiceClient.Logout(request);
return (response.Acknowledge == AcknowledgeType.Success);
}
//todo: explain in comments what is going on here and how this method is related to AuthServerProvider.GrantResourceOwnerCredentials
public LogoutResponse Logout(LogoutRequest request)
{
_commands.ResetPlayerActivityStatus(Username);
Request.GetOwinContext().Authentication.SignOut(); // this doesn't remove cookies, so it's useless. :((
return(new LogoutResponse
{
UserName = Username
});
}
public ActionResult <string> Logout([FromBody] LogoutRequest logoutRequest)
{
if (logoutRequest == null)
{
return(BadRequest());
}
_authRepository.Logout(logoutRequest);
return(Ok());
}
private IActionResult RedirectToLogoutUrl(LogoutRequest context)
{
if (!string.IsNullOrWhiteSpace(context.PostLogoutRedirectUri))
{
return(Redirect(context.PostLogoutRedirectUri));
}
else
{
return(Redirect("~/../"));
}
}
public async Task <IActionResult> Logout(LogoutRequest request)
{
LogoutResponse response = await _authService.LogoutAysnc(request);
if (response.IsValid())
{
return(Ok(response));
}
return(BadRequest(response.GetErrors()));
}
public async Task <IActionResult> OnPostAsync(string logoutId = null, string returnUrl = null)
{
if (logoutId == null)
{
logoutId = await _interaction.CreateLogoutContextAsync();
}
LogoutRequest logoutContext = await _interaction.GetLogoutContextAsync(logoutId);
AutomaticRedirectAfterSignOut = true;
PostLogoutRedirectUri = logoutContext?.PostLogoutRedirectUri;
ClientName = string.IsNullOrEmpty(logoutContext?.ClientName) ? logoutContext?.ClientId : logoutContext?.ClientName;
SignOutIframeUrl = logoutContext?.SignOutIFrameUrl;
// delete the local authentication cookie
await _signInManager.SignOutAsync();
try
{
// delete reference tokens
var subjectId = HttpContext.User.Identity.GetSubjectId();
await _persistedGrantStore.RemoveAllAsync(subjectId, "mvc_hybrid", "reference_token");
await _persistedGrantStore.RemoveAllAsync(subjectId, "js", "reference_token");
await _persistedGrantStore.RemoveAllAsync(subjectId, "react", "reference_token");
// raise the logout event
await _events.RaiseAsync(new UserLogoutSuccessEvent(User.GetSubjectId(), User.GetDisplayName()));
_logger.LogInformation("User logged out.");
// set this so UI rendering sees an anonymous user
HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity());
}
catch (InvalidOperationException ioe)
{
if (ioe.Message == "sub claim is missing")
{
_logger.LogWarning("Logged out user attempting to log out");
}
else
{
throw;
}
}
catch (Exception e)
{
_logger.LogError("Error while attempting to log user out.", e);
}
return(Page());
}
public LogoutResponse Logout(LogoutRequest logoutRequest)
{
// IUserService proxy = factory.CreateChannel();
using (new OperationContextScope((IClientChannel)proxy))
{
AuthenticatedUser currentLogedUser = AuthenticatedUser.Instance;
WebOperationContext.Current.OutgoingRequest.Headers.Add("Authentication", currentLogedUser.Authentication.ToString());
LogoutResponse response = proxy.Logout(logoutRequest);
return(response);
}
}
public int Logout(LogoutRequest logoutRequest)
{
using (DemsifyEntities dataContext = new DemsifyEntities())
{
ObjectParameter result = new ObjectParameter("Result", typeof(int));
dataContext.Logout(Utility.TrimString(logoutRequest.AccessToken), result);
return(Convert.ToInt32(result.Value));
}
}
public LogoutResponse Logout(LogoutRequest request)
{
var response = new LogoutResponse(request.RequestId);
// Validate client tag and access token
//if (!ValidRequest(request, response, Validate.ClientTag | Validate.AccessToken))
// return response;
_userName = null;
return(response);
}
/// <summary>
/// Logout from from the system.
/// </summary>
/// <returns>Success or failure flag.</returns>
public bool Logout()
{
LogoutRequest request = new LogoutRequest();
request.RequestId = NewRequestId;
request.ClientTag = ClientTag;
request.AccessToken = AccessToken;
LogoutResponse response = ActionServiceClient.Logout(request);
return(response.Acknowledge == AcknowledgeType.Success);
}
public void DelegatesControlToAuthenticatedUserApplyer()
{
var securityContext = A.Fake<ISecurityContext>();
var command = new LogoutRequest {
SecurityContext = securityContext
};
_sut.Handle(command).Wait();
A.CallTo(() => securityContext.SetAuthenticatedUser(null))
.MustHaveHappened();
}
public async Task <IActionResult> Logout([FromBody] LogoutRequest request)
{
var logoutData = _mapper.Map <LogoutData>(request);
var authResponse = await _authService.LogoutAsync(logoutData);
if (authResponse.Success)
{
return(NoContent());
}
return(BadRequest(_mapper.Map <AuthFailedResponse>(authResponse)));
}
// logout is currently not support by SFAuthenticationSession
// https://forums.developer.apple.com/thread/91647
private async void LogoutButton_TouchUpInside(object sender, EventArgs e)
{
OutputText.Text = "";
var request = new LogoutRequest
{
IdTokenHint = _user.IdentityToken
};
_user = null;
await _client.LogoutAsync(request);
}
private void OnSwitchToSingleMode()
{
if (Client.Instance.Proxy.ClientState == ProxyBase.ClientStates.Matching)
{
Client.Instance.Proxy.CancelMatch();
}
LogoutRequest request = new LogoutRequest(Client.Instance.Proxy.ClientID, Client.Instance.Proxy.Username);
Client.Instance.Proxy.SendMessage(request);
UIManager.Instance.GetBaseUIForm <LoginPanel>().ReturnToSingleMode();
}
/// <summary>
/// This is the function to logout a user from an IDP.
/// </summary>
public async Task <LogoutResponse> LogoutAsync(LogoutRequest request)
{
var url = GetUrl("Logout", new Dictionary <string, string?>
{
{ "apiKey", _apiKey },
{ "sessionid", request.SessionId }
});
var fullResponse = await GetFullResponseAndEnsureSuccess <LogoutFullResponse>(url);
return(new LogoutResponse(fullResponse));
}
public void DelegatesControlToAuthenticatedUserApplyer()
{
var securityContext = A.Fake <ISecurityContext>();
var command = new LogoutRequest {
SecurityContext = securityContext
};
_sut.Handle(command).Wait();
A.CallTo(() => securityContext.SetAuthenticatedUser(null))
.MustHaveHappened();
}
protected void Unnamed_LoggingOut(object sender, LoginCancelEventArgs e)
{
Session.Clear();
Session.Abandon();
var identity = (ClaimsIdentity)HttpContext.Current.User.Identity;
var identityProvider = identity.FindFirst(ClaimTypes.System);
string email = identity.FindFirst(ClaimTypes.Name).Value;
Context.GetOwinContext().Authentication.SignOut();
if (identityProvider != null)
{
if (identityProvider.Value == AcquisitionEnum.Office365.ToString())
{
LogoutRequest logoutReq = new LogoutRequest();
JObject jsonObj = ConfigService.GetCompanyConfigJsonByHostName(Request.Url.Host, Configuration.OFFICE365_CODE);
logoutReq.Issuer = jsonObj["appID"].ToString();
logoutReq.NameID = email;
string endPoint = jsonObj["endPoint"].ToString();
StringWriter sw = new StringWriter();
XmlTextWriter tw = null;
try
{
XmlSerializer serializer = new XmlSerializer(logoutReq.GetType());
tw = new XmlTextWriter(sw);
serializer.Serialize(tw, logoutReq);
}
catch (Exception ex)
{
}
finally
{
sw.Close();
if (tw != null)
{
tw.Close();
}
}
Response.Redirect(string.Format("{0}?SAMLRequest={1}", endPoint, SamlUtil.EncodeRequest(sw.ToString())));
}
if (identityProvider.Value == AcquisitionEnum.Adfs.ToString())
{
}
}
}
public IHttpActionResult Logout(LogoutRequest request)
{
var cookie = HttpContext.Current.Request.Cookies[FormsAuthentication.FormsCookieName];
if (cookie != null)
{
HttpContext.Current.Response.Cookies.Remove(FormsAuthentication.FormsCookieName);
cookie.Expires = DateTime.Now.AddDays(-10);
cookie.Value = null;
HttpContext.Current.Response.SetCookie(cookie);
}
return(Ok(new { }));
}
private async void Logout_Clicked(object sender, EventArgs e)
{
var logoutRequest = new LogoutRequest();
_isAuthenticated = false;
CallApi.IsVisible = false;
Login.IsVisible = true;
Logout.IsVisible = false;
OutputText.Text = string.Empty;
await _client.LogoutAsync(logoutRequest);
}
public async Task <IActionResult> SignOut(string logoutId)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction(nameof(SignIn), new { signedOut = true }));
}
LogoutRequest logout = await interactionService.GetLogoutContextAsync(logoutId);
await signInManager.SignOutAsync();
return(Redirect("~/account/sign-in"));
}
public IHttpActionResult Logout(LogoutRequest logoutRequest)
{
try
{
Database.DeleteToken(logoutRequest.token);
}
catch (Exception)
{
return(BadRequest());
}
return(Ok());
}
async public Task <LogoutResponse> Logout(string username)
{
LogoutRequest request = new LogoutRequest(username);
comm.SendRequest(request);
LogoutResponse response = await comm.Get <LogoutResponse>();
if (response.Success)
{
Permissions = new Dictionary <int, Permission>();
}
return(response);
}
public Response<bool> Logout(LogoutRequest logoutRequest)
{
JObject request = JObject.FromObject(logoutRequest);
var result = Method(Functions.Logout, request, ParameterValidator.LogoutCheckRequest); //调用 Logout 登录方法
try
{
var logoutResponse = JsonConvert.DeserializeObject<Response<bool>>(result.ToString());
return logoutResponse;
}
catch (Exception e)
{
return Response<bool>.BuildResponse(e);
}
}
private void ProcessLogoutRequest(LogoutRequest logoutRequest, string relayState)
{
Trace.Write("SP", "Processing logout request");
// Logout locally.
FormsAuthentication.SignOut();
Session.Abandon();
// Create a logout response.
LogoutResponse logoutResponse = CreateLogoutResponse();
// Send the logout response.
SendLogoutResponse(ref logoutResponse);
}
public void ShouldDelegateControlToInnerHandler()
{
var securityContext = A.Fake<ISecurityContext>();
ConfigureSecurityContextFactory_ToReturn(securityContext);
var expectedCommand = new LogoutRequest {
SecurityContext = securityContext
};
var response = Post();
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
A.CallTo(() => _logoutHandler
.Handle(A<LogoutRequest>.That.Matches(command => command.HasSamePropertyValuesAs(expectedCommand))))
.MustHaveHappened(Repeated.Exactly.Once);
}
public bool Logout(LogoutRequest request)
{
var session = _db.Sessions.FirstOrDefault(s => s.Id == request.SessionId);
if (session == null)
{
return false;
}
_db.Sessions.Remove(session);
var result = _db.SaveChanges();
if (result > 0)
{
return true;
}
return false;
}
public LogoutResponse Logout(LogoutRequest request)
{
var response = new LogoutResponse { CorrelationId = request.RequestId };
if (!ValidRequest(request, response, Validate.AccessToken))
return response;
_accessToken = null;// Console.WriteLine("Access Token destroyed: " + _accessToken);
_userName = null; // Console.WriteLine("User is logged out: " + _userName);
return response;
}
public FubuContinuation get_logout(LogoutRequest request)
{
return FubuContinuation.EndWithStatusCode(HttpStatusCode.Accepted);
}
protected void lnkInitiateSSO_Click(object sender, EventArgs e)
{
AccountSettings accountSettings = new AccountSettings();
LogoutRequest req = new LogoutRequest(new AppSettings(), accountSettings);
Response.Redirect(accountSettings.idp_slo_target_url + "?SAMLRequest=" + Server.UrlEncode(req.GetRequest(LogoutRequest.LogoutRequestFormat.Base64)));
}
public FubuContinuation Logout(LogoutRequest request)
{
_session.ClearAuthentication();
return _logoutSuccessHandler.LoggedOut();
}
public FubuContinuation Logout(LogoutRequest request)
{
_session.ClearAuthentication();
return FubuContinuation.RedirectTo(new LoginRequest());
}
public FubuContinuation Get(LogoutRequest request)
{
authContext.SignOut();
return FubuContinuation.RedirectTo(new ScoreBoardRequest());
}
/// <summary>
/// Logout from application service.
/// </summary>
/// <param name="request">Logout request message.</param>
/// <returns>Login request message.</returns>
public LogoutResponse Logout(LogoutRequest request)
{
LogoutResponse response = new LogoutResponse();
response.CorrelationId = request.RequestId;
// Validate client tag and access token
if (!ValidRequest(request, response, Validate.ClientTag | Validate.AccessToken))
return response;
_userName = null;
return response;
}
/// <summary>
/// Logs out of the service.
/// </summary>
public void Logout()
{
LogoutRequest request = new LogoutRequest();
request.RequestId = NewRequestId;
request.AccessToken = AccessToken;
request.ClientTag = ClientTag;
LogoutResponse response = null;
SafeProxy.DoAction<ActionServiceClient>(Service, client =>
{ response = client.Logout(request); });
if (request.RequestId != response.CorrelationId)
throw new ApplicationException("Logout: RequestId and CorrelationId do not match.");
if (response.Acknowledge != AcknowledgeType.Success)
throw new ApplicationException(response.Message);
}
public LogoutResponse Logout(LogoutRequest request)
{
LogoutResponse response = new LogoutResponse();
// Set correlation Id
response.CorrelationId = request.RequestId;
try
{
if (request.SecurityToken != "ABC123")
{
response.Acknowledge = AcknowledgeType.Failure;
response.Message = "Invalid Security Token";
}
FormsAuthentication.SignOut();
}
catch // (Exception ex)
{
response.Acknowledge = AcknowledgeType.Failure;
response.Message = "Logout request cannot be handled at this time.";
}
return response;
}
public FubuContinuation Logout(LogoutRequest request)
{
_service.Logout();
return FubuContinuation.RedirectTo<HomeRequest>();
}
public void Logout(LogoutRequest logoutRequest)
{
SendRequest(logoutRequest.ToXML());
}
public IAsyncResult BeginLogout(LogoutRequest logoutRequest)
{
JObject request = JObject.FromObject(logoutRequest);
return BeginMethod(Functions.Logout, request, ParameterValidator.LogoutCheckRequest, LogoutCallBackMethod);
}
private void Logout()
{
logger.Debug("Attempting to log out.");
LogoutRequest logoutRequest = new LogoutRequest();
Messager.Send(logoutRequest, RegistryEndPoint);
}
private static void Main()
{
var cust = new
{
Id = "3",
Name = "Test",
Email = "*****@*****.**",
Address1 = "123 Main St",
City = "Charlotte",
State = "NC",
Zip = "29028",
};
var card = new
{
AccountType = AccountTypes.C,
NameOnCard = "Test",
AccountNumber = "4012000033330026",
RoutingNumber = "123456780",
ExpMonth = (string)null,
ExpYear = (string)null,
};
var trnx = new
{
Amount = 1234.56m,
};
var conn = new VancoConnection(ConfigurationManager.ConnectionStrings["Vanco"].ConnectionString);
// Login
var loginRequest = new LoginRequest();
var loginResponse = loginRequest.Execute(conn);
Console.WriteLine("SessionId: " + loginResponse.SessionId);
// Add Payment method
var eftRequest = new EftRequest
{
CustomerId = cust.Id,
AddNewCustomer = true,
Name = cust.Name,
Email = cust.Email,
BillingAddr1 = cust.Address1,
BillingCity = cust.City,
BillingState = cust.State,
BillingZip = cust.Zip,
AccountType = card.AccountType,
NameOnCard = card.NameOnCard,
AccountNumber = card.AccountNumber,
RoutingNumber = card.RoutingNumber,
ExpMonth = card.ExpMonth,
ExpYear = card.ExpYear,
};
var eftResponse = eftRequest.Execute(conn);
Console.WriteLine("PaymentMethodRef: " + eftResponse.PaymentMethodRef);
// Get Payment Methods
var methodsRequest = new PaymentMethodsRequest
{
CustomerId = cust.Id,
};
var methodsResponse = methodsRequest.Execute(conn);
Console.WriteLine("PaymentMethods: " + methodsResponse.PaymentMethodCount);
// Transaction
var trnxRequest = new TransactionRequest
{
CustomerId = cust.Id,
PaymentMethodRef = methodsResponse.PaymentMethods[methodsResponse.PaymentMethods.Count - 1].PaymentMethodRef,
Amount = trnx.Amount,
FrequencyCode = Frequencies.O,
};
var trnxResponse = trnxRequest.Execute(conn);
if (!string.IsNullOrWhiteSpace(trnxResponse.ErrorList))
{
Console.WriteLine("Error: " + VancoConnection.GetErrorMessages(trnxResponse.ErrorList));
}
Console.WriteLine("TrnxId: " + trnxResponse.TransactionRef);
// Logout
var logout = new LogoutRequest().Execute(conn);
Console.WriteLine("Logout: " + logout);
Console.ReadKey();
}
