private void ProcessLogoutResponse(LogoutResponse logoutResponse, string relayState)
{
Trace.Write("IdP", "Processing logout response");
// Redirect to the default page.
Response.Redirect("~/", false);
}
public ActionResult Logout()
{
logger.Info("begin");
try
{
//Ho una delega in esercizio la dismetto prima
if (NavigationHandler.DeleganteInfo != null)
{
DismettiDelegaRequest delegaRequest = new DismettiDelegaRequest();
delegaRequest.IdDelegante = NavigationHandler.DeleganteInfo.UserId;
delegaRequest.UserInfo = NavigationHandler.CurrentUser;
DismettiDelegaResponse response = WSStub.dismettiDelega(delegaRequest);
if (response.Code == DismettiDelegaResponseCode.OK)
{
NavigationHandler.DeleganteInfo = null;
NavigationHandler.ToDoListMemento = null;
NavigationHandler.RicercaMemento = null;
NavigationHandler.DelegaEsercitata = null;
}
}
LogoutRequest request = new LogoutRequest();
request.UserInfo = NavigationHandler.CurrentUser;
LogoutResponse resp = WSStub.logout(request);
logger.Info("logout success");
}
catch (Exception e)
{
logger.Info("exception: " + e);
}
NavigationHandler.clearSession();
logger.Info("end");
return(RedirectToAction("Login", "Login"));
}
public void Logout_Test()
{
LogoutRequest request = new LogoutRequest {
Context = "NG", Token = "531ddd4ed6a4850398308056"
};
LogoutResponse response = SecurityManager.Logout(request, "Engineer");
}
public LogoutResponse Logout([FromBody] LogoutRequest logoutRequest)
{
var response = new LogoutResponse();
try
{
if (logoutRequest == null || string.IsNullOrWhiteSpace(logoutRequest.Token))
{
throw new APIException("Token cannot be null");
}
LoginResponse loginResponse = null;
loginResponse = Storage.IssuedTokens.SingleOrDefault(t => t.Token == logoutRequest.Token);
if (loginResponse != null)
{
Storage.IssuedTokens.TryTake(out loginResponse);
}
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
response.ErrorMessage = "Logout failed.";
LogException(IdentityServer.API.EventIds.Logout, ex);
}
return(response);
}
public LogoutResponse Logout()
{
LogoutResponse logout = new LogoutResponse();
try
{
LogoutRequest requestLogout = new LogoutRequest();
requestLogout.ClientId = apiClientId;
requestLogout.EndUserIp = IPAddress;
requestLogout.TokenAgencyId = BLFunction.GetAgencyID();
requestLogout.TokenMemberId = BLFunction.GetMemberID();
requestLogout.TokenId = BLFunction.GetTokenID();
var jsonStringObject = JsonConvert.SerializeObject(requestLogout);
String Qualifiedurl = Baseurl + "SharedServices/SharedData.svc/rest/Logout";
var result = APIHotel.Instance().GetResponse(Qualifiedurl, Verbs.POST, jsonStringObject);
if (result != null)
{
logout = JsonConvert.DeserializeObject <LogoutResponse>(result);
}
return(logout);
}
catch (Exception ex)
{
logout.Error.ErrorMessage = ex.Message;
return(logout);
}
}
public async Task <ActionResult> LogoutIdp(IFormCollection collection)
{
string samlResponse = "";
LogoutResponse resp = new LogoutResponse();
try
{
samlResponse = Encoding.UTF8.GetString(Convert.FromBase64String(collection["SAMLResponse"]));
resp.Deserialize(samlResponse);
}
catch (Exception ex)
{
//TODO LOG
}
//if (resp.RequestStatus == AuthResponse.SamlRequestStatus.Success)
//{
// //OK
//};
return(Redirect("/"));
}
public IEnumerator Logout(string token, OnRequestComplete complete, OnRequestError error)
{
string url = routes.Single(route => route.Key == "logout").Value;
UnityWebRequest request = UnityWebRequest.Post(url, "");
request.SetRequestHeader("Accept", "application/json");
request.SetRequestHeader("Authorization", "Bearer " + token);
yield return(request.SendWebRequest());
if (request.isNetworkError || request.isHttpError)
{
error(request.error);
}
else
{
try {
String json = request.downloadHandler.text;
LogoutResponse response = JsonUtility.FromJson <LogoutResponse>(json);
if (response.success)
{
complete();
}
else
{
error(response.error.message);
}
}
catch (Exception ex) {
error(ex.ToString());
}
}
}
public LogoutResponse Logout(string id)
{
logger.Debug(Settings.MethodName());
logger.Trace("Parameters: id: " + id);
long userid;
long.TryParse(id, out userid);
S_User user = UserManager.GetUserById(userid);
if (user != null)
{
user.logindatetime = null;
UserManager.Update(user);
logger.Trace("Return: Status: OK");
return(new LogoutResponse {
status = "OK"
});
}
else
{
LogoutResponse r = new LogoutResponse();
r.status = "NOTOK";
logger.Trace("Return: Status: " + r.status);
return(r);
}
}
public void ValidateLogoutRequest(string requestType, System.Collections.Specialized.NameValueCollection requestParams, Uri requestUrl)
{
logger.DebugFormat(TraceMessages.LogoutResponseReceived);
var message = string.Empty;
LogoutResponse response = null;
switch (requestType)
{
case "GET":
ValidateLogoutViaGet(requestUrl, out message, out response);
break;
case "POST":
ValidateLogoutViaPost(requestParams, out message, out response);
break;
default:
break;
}
if (response == null)
{
logger.ErrorFormat(ErrorMessages.UnsupportedRequestType, requestType);
throw new Saml20Exception(string.Format(ErrorMessages.UnsupportedRequestType, requestType));
}
logger.DebugFormat(TraceMessages.LogoutResponseParsed, message);
if (response.Status.StatusCode.Value != Saml20Constants.StatusCodes.Success)
{
logger.ErrorFormat(ErrorMessages.ResponseStatusNotSuccessful, response.Status.StatusCode.Value);
throw new Saml20Exception(string.Format(ErrorMessages.ResponseStatusNotSuccessful, response.Status.StatusCode.Value));
}
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
LogoutResponse response = new LogoutResponse();
return(response);
}
public virtual IHttpActionResult Logout(LogoutRequest logoutRequest)
{
if (logoutRequest == null)
{
throw new ArgumentNullException(nameof(logoutRequest));
}
var response = new LogoutResponse();
if (!logoutRequest.PreserveCustomerInfo)
{
InvalidateCustomerCookie();
}
FormsAuthentication.SignOut();
response.ReturnUrl = logoutRequest.ReturnUrl;
if (string.IsNullOrWhiteSpace(response.ReturnUrl) || !UrlFormatter.IsReturnUrlValid(RequestUtils.GetBaseUrl(Request).ToString(), response.ReturnUrl))
{
response.ReturnUrl = MyAccountUrlProvider.GetLoginUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
});
}
return(Ok(response));
}
private void TransakcjaStop(TradeRecord tradeRecordStop)
{
try
{
SyncAPIConnector connector = new SyncAPIConnector(serverData);
Credentials credentials = new Credentials(userId, password, "", "pixelNet");
LoginResponse loginResponse = APICommandFactory.ExecuteLoginCommand(connector, credentials, true);
TRADE_OPERATION_CODE toc;
if (tradeRecordStop.Cmd == 1)
{
toc = TRADE_OPERATION_CODE.SELL;
}
else
{
toc = TRADE_OPERATION_CODE.BUY;
}
double price = tradeRecordStop.Close_price.GetValueOrDefault();
double sl = 0.0;
double tp = 0.0;
string symbol = tradeRecordStop.Symbol;
double?volume = tradeRecordStop.Volume;
long order = tradeRecordStop.Order.GetValueOrDefault();
long expiration = 0;
TradeTransInfoRecord ttCloseInfoRecord = new TradeTransInfoRecord(
toc,
TRADE_TRANSACTION_TYPE.ORDER_CLOSE,
price, sl, tp, symbol, volume, order, "", expiration);
TradeTransactionResponse closeTradeTransactionResponse = APICommandFactory.ExecuteTradeTransactionCommand(connector, ttCloseInfoRecord, true);
LogoutResponse logoutResponse = APICommandFactory.ExecuteLogoutCommand(connector);
}
catch (Exception e) { MessageBox.Show(e.Message); }
}
void HandleLogoutRequest(LogoutRequest packet)
{
Player pl = GetPlayer();
if (!GetPlayer().GetLootGUID().IsEmpty())
{
GetPlayer().SendLootReleaseAll();
}
bool instantLogout = (pl.HasFlag(PlayerFields.Flags, PlayerFlags.Resting) && !pl.IsInCombat() ||
pl.IsInFlight() || HasPermission(RBACPermissions.InstantLogout));
bool canLogoutInCombat = pl.HasFlag(PlayerFields.Flags, PlayerFlags.Resting);
int reason = 0;
if (pl.IsInCombat() && !canLogoutInCombat)
{
reason = 1;
}
else if (pl.IsFalling())
{
reason = 3; // is jumping or falling
}
else if (pl.duel != null || pl.HasAura(9454)) // is dueling or frozen by GM via freeze command
{
reason = 2; // FIXME - Need the correct value
}
LogoutResponse logoutResponse = new LogoutResponse();
logoutResponse.LogoutResult = reason;
logoutResponse.Instant = instantLogout;
SendPacket(logoutResponse);
if (reason != 0)
{
SetLogoutStartTime(0);
return;
}
// instant logout in taverns/cities or on taxi or for admins, gm's, mod's if its enabled in worldserver.conf
if (instantLogout)
{
LogoutPlayer(true);
return;
}
// not set flags if player can't free move to prevent lost state at logout cancel
if (pl.CanFreeMove())
{
if (pl.GetStandState() == UnitStandStateType.Stand)
{
pl.SetStandState(UnitStandStateType.Sit);
}
pl.SetRooted(true);
pl.SetFlag(UnitFields.Flags, UnitFlags.Stunned);
}
SetLogoutStartTime(Time.UnixTime);
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
try
{
#region Receive logout request
X509Certificate2 x509Certificate = (X509Certificate2)Application[Global.SPCertKey];
LogoutRequest logoutRequest = LogoutRequest.Create(Request, x509Certificate.PublicKey.Key);
#endregion
// Logout locally.
FormsAuthentication.SignOut();
Session.Abandon();
// You can send a logout request to any other service providers here.
// ...
// Create a logout response
LogoutResponse logoutResponse = new LogoutResponse();
logoutResponse.Issuer = new Issuer(Util.GetAbsoluteUrl(this, "~/"));
#region Send Logout Response
// Look up for the appropriate logout SP url
string referer = this.Request.UrlReferrer.AbsoluteUri;
int i;
for (i = 0; i < Services.AllowedServiceUrls.Length; i++)
{
string url = Services.AllowedServiceUrls[i];
if (referer.StartsWith(url))
{
break;
}
}
if (i == Services.AllowedServiceUrls.Length)
{
throw new Exception("Your SP is not allowed");
}
// Send the logout response over HTTP redirect.
string logoutUrl = Services.LogoutServiceProviderUrls[i];
x509Certificate = (X509Certificate2)Application[Global.SPCertKey];
logoutResponse.Redirect(Response, logoutUrl, logoutRequest.RelayState, x509Certificate.PrivateKey);
#endregion
}
catch (Exception exception)
{
Trace.Write("IdP", "Error in single logout service", exception);
}
}
protected void lnkbLogOut_Click(object sender, EventArgs e)
{
LogoutResponse lgresp = DataProviderWrapper.Instance.Logout();
Session.Abandon();
FormsAuthentication.SignOut();
Response.RedirectToRoute("Login");
}
public virtual LogoutResponse Execute(LogoutRequest request)
{
LogoutResponse response;
response = new LogoutResponse();
RQL.RQLExecuteUtil.Execute(request, response);
return(response);
}
public string logout(string session)
{
LogoutRequest request = new LogoutRequest();
request.session = session;
LogoutResponse response = client.Logout(request);
return(response.status);
}
public async Task <ActionResult <LogoutResponse> > Logout(LogoutRequest request, CancellationToken cancellationToken)
{
//invalidate refresh token
Response.Cookies.Delete("accessToken");
var response = new LogoutResponse();
return(Ok(response));
}
public LogoutResponsePDU(byte[] buffer, int offset) : base(buffer, offset)
{
Response = (LogoutResponse)OpCodeSpecificHeader[1];
StatSN = BigEndianConverter.ToUInt32(OpCodeSpecific, 4);
ExpCmdSN = BigEndianConverter.ToUInt32(OpCodeSpecific, 8);
MaxCmdSN = BigEndianConverter.ToUInt32(OpCodeSpecific, 12);
TimeToWait = BigEndianConverter.ToUInt16(OpCodeSpecific, 20);
TimeToRetain = BigEndianConverter.ToUInt16(OpCodeSpecific, 22);
}
public void Logout_Test()
{
IRestClient client = new JsonServiceClient();
LogoutResponse response = client.Post <LogoutResponse>("http://localhost:888/security/1.0/logout",
new LogoutRequest {
Context = "NG", Token = "53162017072ef71b5c3d8e4f"
} as object);
Assert.AreEqual(response.SuccessfulLogout, true);
}
/// <summary>
/// Initializes a new instance of the <see cref="Saml20LogoutResponse"/> class.
/// </summary>
public Saml20LogoutResponse()
{
_response = new LogoutResponse();
_response.Version = Saml20Constants.Version;
_response.ID = "id" + Guid.NewGuid().ToString("N");
_response.Issuer = new NameID();
_response.IssueInstant = DateTime.Now;
_response.Status = new Status();
_response.Status.StatusCode = new StatusCode();
}
public async Task <IActionResult> Logout(LogoutRequest request)
{
LogoutResponse response = await _authService.LogoutAysnc(request);
if (response.IsValid())
{
return(Ok(response));
}
return(BadRequest(response.GetErrors()));
}
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);
}
}
// Create a logout response.
private LogoutResponse CreateLogoutResponse()
{
Trace.Write("SP", "Creating logout response.");
LogoutResponse logoutResponse = new LogoutResponse();
logoutResponse.Status = new Status(SAMLIdentifiers.PrimaryStatusCodes.Success, null);
logoutResponse.Issuer = new Issuer(CreateAbsoluteURL("~/"));
Trace.Write("SP", "Created logout response.");
return logoutResponse;
}
public override void OnLogoutResponseReceived(LogoutResponse logoutResponse)
{
// Check the logout response status – details not shown.
if (logoutResponse.IsSuccess())
{
System.Diagnostics.Debug.WriteLine("logoutResponse is Success");
}
else
{
System.Diagnostics.Debug.WriteLine("logoutResponse is NOT Success");
}
}
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);
}
/// <summary>
/// Initializes a new instance of the <see cref="Saml20LogoutResponse"/> class.
/// </summary>
public Saml20LogoutResponse()
{
Response = new LogoutResponse
{
Version = Saml20Constants.Version,
ID = "id" + Guid.NewGuid().ToString("N"),
Issuer = new NameId(),
IssueInstant = DateTime.Now,
Status = new Status {
StatusCode = new StatusCode()
}
};
}
// Create a logout response.
private LogoutResponse CreateLogoutResponse()
{
Trace.Write("SP", "Creating logout response.");
LogoutResponse logoutResponse = new LogoutResponse();
logoutResponse.Status = new Status(SAMLIdentifiers.PrimaryStatusCodes.Success, null);
logoutResponse.Issuer = new Issuer(CreateAbsoluteURL("~/"));
Trace.Write("SP", "Created logout response.");
return(logoutResponse);
}
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);
}
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);
}
protected void Page_Load(object sender, EventArgs e)
{
AccountSettings accountSettings = new AccountSettings();
LogoutResponse samlResponse = new LogoutResponse(accountSettings);
samlResponse.LoadXmlFromBase64(Request.Form["SAMLResponse"]);
if(samlResponse.IsValid())
{
HttpContext.Current.Session["user"] = "";
lblMsg.Text = "<h1>You are logged out</h1>";
}
else
{
lblMsg.Text = "Logout failed";
}
//Response.Write(samlResponse.ToString());
}
/// <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;
}
private void LogoutFinished(object sender, logoutCompletedEventArgs e)
{
object[] state = (object[])e.UserState;
OperationFinished<LogoutResponse> logoutFinishedHandler = (OperationFinished<LogoutResponse>)state[0];
LogoutResponse response;
if (e.Error != null)
{
response = new LogoutResponse
{
Status = LogoutStatus.Failed,
UserState = state[1],
Error = e.Error
};
}
else
{
response = new LogoutResponse
{
Status = StatusMessageParser.ParseLogoutStatus(e.Result),
UserState = state[1]
};
response.Error = response.Status == LogoutStatus.Unknown
?
new UnknownOperationStatusException(e.Result)
:
null;
}
logoutFinishedHandler(response);
}
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;
}
private void ProcessLogoutResponse(LogoutResponse logoutResponse, string relayState)
{
Trace.Write("IdP", "Processing logout response");
// Redirect to the default page.
Response.Redirect("~/", false);
}
// Send the logout response.
private void SendLogoutResponse(ref LogoutResponse logoutResponse)
{
Trace.Write("SP", "Sending logout response.");
// Serialize the logout response for transmission.
XmlElement logoutResponseXml = logoutResponse.ToXml();
// Send the logout response over HTTP redirect.
X509Certificate2 x509Certificate = (X509Certificate2) Application[Global.SPX509Certificate];
SingleLogoutService.SendLogoutResponseByHTTPRedirect(Response, WebConfigurationManager.AppSettings["idpLogoutURL"], logoutResponseXml, null, x509Certificate.PrivateKey);
Trace.Write("SP", "Sent logout response.");
}
