public bool IsValidSession(DbConnect con, string token, int user_id) { if (!App.CheckToken) { return(true); } DynamicDictionary tokenDetail = GetTokenDetail(token, user_id); if (tokenDetail == null || tokenDetail.GetCount() == 0) { return(false); } if (tokenDetail.ContainsKey("expire_datetime")) { if (!String.IsNullOrEmpty(tokenDetail["expire_datetime"].ToString())) { DateTime expiryDate = Convert.ToDateTime(tokenDetail["expire_datetime"]); DateTime current_date = DateTime.Now; TimeSpan difference = expiryDate - current_date; if (difference.TotalMinutes < 0) { Status = AuthorizationStatus.SessionExpired; return(false); } else { SessionData.client_id = tokenDetail.GetValueAsInt("client_id"); return(true); } } } return(false); }
public bool CancelSessionKeys(int idUser, AuthorizationStatus oldStatus, DateTime dateBlock, AuthorizationStatus newStatus) { var idParam = new SqlParameter { ParameterName = "@IdEntity", Value = idUser }; var oldStatusParam = new SqlParameter { ParameterName = "@OldStatus", Value = oldStatus.GetStatusName() }; var finishKeyParam = new SqlParameter { ParameterName = "@FinishSession", Value = dateBlock }; var newStatusParam = new SqlParameter { ParameterName = "@NewStatus", Value = newStatus.GetStatusName() }; ExecuteCommand(SpCancelSessionKey, idParam, oldStatusParam, finishKeyParam, newStatusParam); return(true); }
private void CheckCredentials() { if (_accessToken.IsValid) VerifyCredentialsWithTwitter(); else AuthorizationStatus = AuthorizationStatus.Unauthorized; }
void AuthorizationStatusFetched(string status) { Debug.Log("AuthorizationStatusFetched" + status); AuthorizationStatus authStatus = AuthorizationStatus.NotDetermined; switch (status) { case "denied": authStatus = AuthorizationStatus.Denied; break; case "authorized": authStatus = AuthorizationStatus.Authorized; break; case "restricted": authStatus = AuthorizationStatus.Restricted; break; case "notDetermined": authStatus = AuthorizationStatus.NotDetermined; break; } onAuthorizationStatusFetched.Invoke(authStatus); }
public static async Task <bool> TryConsumeAuthCode(ulong guildID, string code) { CollectionReference authDocument = Db.Document("_authorizeKeys").Collection(code); QuerySnapshot authDocumentSnapshot = await authDocument.GetSnapshotAsync(); if (authDocumentSnapshot.Documents.Count > 0) { DocumentSnapshot authDoc = authDocumentSnapshot.Documents[0]; DocumentReference authRef = authDoc.Reference; AuthorizationStatus authStatus = authDoc.ConvertTo <AuthorizationStatus>(); if (authStatus.used) { return(false); } else { authStatus.used = true; authStatus.sid = guildID; await authRef.SetAsync(authStatus); await SetAuthFor(guildID, true); return(true); } } return(false); }
public bool CancelSessionKeys(UserSystem userSystem, AuthorizationStatus oldStatus, DateTime dateBlock, AuthorizationStatus newStatus) { if (!userSystem.IdEntity.HasValue) { throw new ArgumentException($"Parameter {nameof(userSystem.IdEntity)} must be not empty", nameof(userSystem.IdEntity)); } var idParam = new SqlParameter { ParameterName = "@IdEntity", Value = userSystem.IdEntity.Value }; var oldStatusParam = new SqlParameter { ParameterName = "@OldStatus", Value = oldStatus.GetStatusName() }; var finishKeyParam = new SqlParameter { ParameterName = "@FinishSession", Value = dateBlock }; var newStatusParam = new SqlParameter { ParameterName = "@NewStatus", Value = newStatus.GetStatusName() }; ExecuteCommand(SpCancelSessionKey, idParam, oldStatusParam, finishKeyParam, newStatusParam); return(true); }
/// <summary> /// Return the HashCode of this object. /// </summary> /// <returns>The HashCode of this object.</returns> public override Int32 GetHashCode() { unchecked { return(AuthorizationStatus.GetHashCode() * 23 ^ GeoCoordinates.GetHashCode() * 19 ^ (ChargingStationName != null ? ChargingStationName.GetHashCode() * 17 : 0) ^ (Address != null ? Address.GetHashCode() * 13 : 0) ^ (SessionId.HasValue ? SessionId.Value.GetHashCode() * 11 : 0) ^ (StatusCode != null ? StatusCode.GetHashCode() * 7 : 0) ^ (TermsOfUse != null ? TermsOfUse.GetHashCode() * 5 : 0) ^ (AdditionalInfo != null ? AdditionalInfo.GetHashCode() * 3 : 0)); } }
/// <summary> /// Get secure PAN. /// </summary> /// <param name="sender">Get PAN button.</param> /// <param name="e">Click event arguments</param> private void GetPan(object sender, RoutedEventArgs e) { string maskedPan; // Limpa o log: this.uxLog.Items.Clear(); ICardPaymentAuthorizer currentAuthorizer = this.GetCurrentPinpad(); if (currentAuthorizer == null) { this.Log("Selecione um pinpad."); return; } // Get PAN: AuthorizationStatus status = currentAuthorizer.GetSecurePan(out maskedPan); // Verifies if PAN was captured correctly: if (string.IsNullOrEmpty(maskedPan) == true || status != AuthorizationStatus.Approved) { this.Log("O PAN não pode ser capturado."); } else { this.Log(string.Format("PAN capturado: {0}", maskedPan)); } }
/// <summary> /// Get autthorize result /// </summary> /// <param name="status">Verification status</param> /// <returns></returns> public static AuthorizeResult GetAuthorizeResult(AuthorizationStatus status = AuthorizationStatus.Forbid) { return(new AuthorizeResult() { Status = status }); }
/// <summary> /// Compares two mobile authorization start for equality. /// </summary> /// <param name="MobileAuthorizationStart">A mobile authorization start to compare with.</param> /// <returns>True if both match; False otherwise.</returns> public override Boolean Equals(MobileAuthorizationStart MobileAuthorizationStart) { if ((Object)MobileAuthorizationStart == null) { return(false); } return(AuthorizationStatus.Equals(MobileAuthorizationStart.AuthorizationStatus) && GeoCoordinates.Equals(MobileAuthorizationStart.GeoCoordinates) && ((ChargingStationName != null && MobileAuthorizationStart.ChargingStationName != null) || (ChargingStationName == null && MobileAuthorizationStart.ChargingStationName == null && ChargingStationName.Equals(MobileAuthorizationStart.ChargingStationName))) && ((Address != null && MobileAuthorizationStart.Address != null) || (Address == null && MobileAuthorizationStart.Address == null && Address.Equals(MobileAuthorizationStart.Address))) && ((!SessionId.HasValue && !MobileAuthorizationStart.SessionId.HasValue) || (SessionId.HasValue && MobileAuthorizationStart.SessionId.HasValue && SessionId.Value.Equals(MobileAuthorizationStart.SessionId.Value))) && ((StatusCode != null && MobileAuthorizationStart.StatusCode != null) || (StatusCode == null && MobileAuthorizationStart.StatusCode == null && StatusCode.Equals(MobileAuthorizationStart.StatusCode))) && ((TermsOfUse != null && MobileAuthorizationStart.TermsOfUse != null) || (TermsOfUse == null && MobileAuthorizationStart.TermsOfUse == null && TermsOfUse.Equals(MobileAuthorizationStart.TermsOfUse))) && ((AdditionalInfo != null && MobileAuthorizationStart.AdditionalInfo != null) || (AdditionalInfo == null && MobileAuthorizationStart.AdditionalInfo == null && AdditionalInfo.Equals(MobileAuthorizationStart.AdditionalInfo)))); }
/// <summary> /// When overridden, provides an entry point for custom authentication checks. /// </summary> /// <param name="httpContext">The HTTP context, which encapsulates all HTTP-specific information about an individual HTTP request.</param> /// <param name="authorizationStatus"><c>AuthorizationStatus</c> value.</param> /// <returns>Returns <c>True</c>, if the user is authenticated; otherwise returns <c>False</c>.</returns> /// <remarks>This method must be thread-safe since it is called by the thread-safe OnCacheAuthorization() method.</remarks> protected virtual bool AuthorizeCore(HttpContextBase httpContext, out AuthorizationStatus authorizationStatus) { if (httpContext == null) { throw new ArgumentNullException("httpContext"); } IPrincipal user = httpContext.User; if (!user.Identity.IsAuthenticated) { authorizationStatus = AuthorizationStatus.Unauthorized; return(false); } if (_usersSplit.Length > 0 && !_usersSplit.Contains(user.Identity.Name, StringComparer.OrdinalIgnoreCase)) { authorizationStatus = AuthorizationStatus.Unauthorized; return(false); } if (_rolesSplit.Length > 0 && !_rolesSplit.Any(user.IsInRole)) { authorizationStatus = AuthorizationStatus.Forbidden; return(false); } authorizationStatus = AuthorizationStatus.Accepted; return(true); }
internal static AuthorizationResult FromStatus(AuthorizationStatus status) { if (status == AuthorizationStatus.Success) { throw new InvalidOperationException("Use the FromUri builder"); } var result = new AuthorizationResult() { Status = status }; if (status == AuthorizationStatus.UserCancel) { result.Error = MsalError.AuthenticationCanceledError; #if ANDROID result.ErrorDescription = MsalErrorMessage.AuthenticationCanceledAndroid; #else result.ErrorDescription = MsalErrorMessage.AuthenticationCanceled; #endif } else if (status == AuthorizationStatus.UnknownError) { result.Error = MsalError.UnknownError; result.ErrorDescription = MsalErrorMessage.Unknown; } return(result); }
public RavenActionAttribute(string path, string method, AuthorizationStatus requireAuth, bool isDebugInformationEndpoint = false) { Path = path; Method = method; IsDebugInformationEndpoint = isDebugInformationEndpoint; RequiredAuthorization = requireAuth; }
private void HandleEncryptionResponse(EncryptionResponsePacket packet) { if (Authorized) { return; } if (AuthorizationStatus.HasFlag(AuthorizationStatus.EncryprionEnabled)) { var pkcs = new PKCS1Signer(Module.Security.RSAKeyPair); var decryptedToken = pkcs.DeSignData(packet.VerificationToken); for (var i = 0; i < VerificationToken.Length; i++) { if (decryptedToken[i] != VerificationToken[i]) { SendPacket(new AuthorizationDisconnectPacket { Reason = "Unable to authenticate." }); return; } } Array.Clear(VerificationToken, 0, VerificationToken.Length); var sharedKey = pkcs.DeSignData(packet.SharedSecret); Stream = new ProtobufTransmission <SCONPacket>(Socket, new BouncyCastleAesStream(Socket, sharedKey)); } else { SendPacket(new AuthorizationDisconnectPacket { Reason = "Encryption not enabled!" }); } }
public void Deauthorize() { AuthorizationStatus = AuthorizationStatus.Unauthorized; _accessTokenStore.Save(new AccessToken(AccessToken.DefaultCredentialsId, null, null)); }
public void CanExecute_WhenUnableToAuthorize_IsFalse(AuthorizationStatus status) { AuthorizeCommand test = BuildDefaultTestSubject(); ClientAuthorizationStatusChangesTo(status); test.CanExecute(null).Should().Be.False(); }
/// <summary> /// Create a new identification tag info. /// </summary> /// <param name="Status">The authentication result.</param> /// <param name="ExpiryDate">An optional date at which the idTag should be removed from the authorization cache.</param> /// <param name="ParentIdTag">An optional the parent-identifier.</param> public IdTagInfo(AuthorizationStatus Status, DateTime?ExpiryDate = null, IdToken?ParentIdTag = null) { this.Status = Status; this.ExpiryDate = ExpiryDate; this.ParentIdTag = ParentIdTag; }
public void CanExecute_WhenAbleToAuthorize_IsTrue(AuthorizationStatus status) { AuthorizeCommand test = BuildDefaultTestSubject(); ClientAuthorizationStatusChangesTo(status); Assert.True(test.CanExecute(null)); }
public void Deauthorize() { AuthorizationStatus = AuthorizationStatus.NotAuthorized; _credentialsStore.Save(new TwitterCredentials(_credentials.ConsumerKey, _credentials.ConsumerSecret, null, null)); }
public void CanExecute_WhenNotAuthorized_ReturnsFalse(AuthorizationStatus status) { DeauthorizeCommand test = BuildDefaultTestSubject(); ClientAuthorizationStatusChangesTo(status); Assert.False(test.CanExecute(null)); }
public RouteInformation(string method, string path, AuthorizationStatus authorizationStatus, bool skipUsagesCount, bool isDebugInformationEndpoint = false) { AuthorizationStatus = authorizationStatus; IsDebugInformationEndpoint = isDebugInformationEndpoint; Method = method; Path = path; SkipUsagesCount = skipUsagesCount; }
public void Deserialize(BinaryReader reader) { Status = (AuthorizationStatus)reader.ReadByte(); if (Status == AuthorizationStatus.Succeed) { AccessToken = reader.ReadString(); } }
protected AuthorizationCommand(ITwitterClient client, AuthorizationStatus executableStatus) { Client = client; _executableStatus = executableStatus; _observer = new PropertyObserver<ITwitterClient>(Client). RegisterHandler(x => x.AuthorizationStatus, y => OnCanExecuteChanged()); }
private bool CancelOldSessionToken(int idUser) { AuthorizationStatus oldStatus = new AuthorizationStatus(AuthorizationStatus.AuthorizationStatusEnum.Active); AuthorizationStatus newStatus = new AuthorizationStatus(AuthorizationStatus.AuthorizationStatusEnum.BlockNewAuthorization); var result = _dbContext.UserAuthorizationsToken.CancelSessionKeys(idUser, oldStatus, DateTime.Now, newStatus); return(result); }
public static AuthorizationResult FromStatus(AuthorizationStatus status, string error, string errorDescription) { return(new AuthorizationResult() { Status = status, Error = error, ErrorDescription = errorDescription, }); }
public void GettingAuthorization__ReturnsStatusFromClient(AuthorizationStatus status) { ClientAuthorizationStatusChangesTo(status); StatusScreen test = BuildDefaultTestSubject(); test.Initialize(); test.Authorization.Should().Equal(status); }
private void ClientAuthorizationStatusChangesTo(AuthorizationStatus authorizationStatus) { _fakeClient. Setup(x => x.AuthorizationStatus). Returns(authorizationStatus); _fakeClient.Raise(x => x.PropertyChanged += null, new PropertyChangedEventArgs("AuthorizationStatus")); }
protected override void OnAuthorized() { var noticeWindow = UserInterfaceContainer.Instance.Get <NoticeWindow>().AssertNotNull(); noticeWindow.Hide(); authorizationStatus = AuthorizationStatus.Succeed; GameServerSelectorController.Instance.ShowGameServerSelectorUI(); }
public RavenActionAttribute(string path, string method, AuthorizationStatus requireAuth, bool isDebugInformationEndpoint = false, bool isPosixSpecificEndpoint = false, CorsMode corsMode = CorsMode.None) { Path = path; Method = method; IsDebugInformationEndpoint = isDebugInformationEndpoint; RequiredAuthorization = requireAuth; IsPosixSpecificEndpoint = isPosixSpecificEndpoint; CorsMode = corsMode; }
protected override void OnAuthorized() { var chatWindow = UserInterfaceContainer.Instance.Get <ChatWindow>().AssertNotNull(); chatWindow.AddMessage("Connected to a chat server successfully.", ChatMessageColor.Green); authorizationStatus = AuthorizationStatus.Succeed; ChatController.Instance.OnAuthorized(); }
public void CheckAuthorization() { _credentials = _credentialsStore.Load(); if (string.IsNullOrEmpty(_credentials.ConsumerKey) || string.IsNullOrEmpty(_credentials.ConsumerSecret)) AuthorizationStatus = AuthorizationStatus.InvalidApplication; else CheckCredentials(); }
protected override void OnAuthorized() { var noticeWindow = UserInterfaceContainer.Instance.Get <NoticeWindow>().AssertNotNull(); noticeWindow.Hide(); authorizationStatus = AuthorizationStatus.Succeed; onAuthorized.Invoke(); }
protected virtual void OnLoggedOut(LogoutStatus status) { if (_authorizationStatus != AuthorizationStatus.None) { _authorizationStatus = AuthorizationStatus.None; if (LoggedOut != null) { LoggedOut(this, new System.EventArgs()); } } }
private void SetStatus(string type, String name, String authorizationKey, AuthorizationStatus status) { var key = GetKeyInternal(authorizationKey, true); var cacheKey = String.Format("{0}:{1}:{2}", type, name, authorizationKey); var model = GetModel(type, name, authorizationKey, true); model.Status = status; if (_store.Save(model)) { this._cache[cacheKey] = status; } }
public UserAuthorizationToken(DateTime startSession, DateTime finishSession, string userToken, AuthorizationStatus authorizationStatus, int userId) { StartSession = startSession; FinishSession = finishSession; UserToken = userToken; //Status = authorizationStatus.GetStatusName(); UserId = userId; AuthorizationStatus = authorizationStatus; UserSystem = null; }
public UserAuthorizationToken(int idAuthorization, DateTime startSession, DateTime finishSession, string userToken, string authorizationStatus, int userId) : base(idAuthorization) { StartSession = startSession; FinishSession = finishSession; UserToken = userToken; //Status = authorizationStatus; UserId = userId; AuthorizationStatus = new AuthorizationStatus(authorizationStatus); UserSystem = null; }
internal static string ToSerializedValue(this AuthorizationStatus value) { switch (value) { case AuthorizationStatus.Disabled: return("Disabled"); case AuthorizationStatus.Enabled: return("Enabled"); } return(null); }
/// <summary> /// Create a new status information about an identifier. /// </summary> /// <param name="status">The authorization status.</param> /// <param name="chargingPriority">The optional charging priority from a business point of view, ranging from -9 to 9 with a default value of 0. Higher values indicate a higher priority.</param> /// <param name="cacheExpiryDateTime">The optional timestamp after which the token must be considered invalid.</param> /// <param name="evseIds">The identification token is only valid fot the given optional enumeration of EVSE identifications.</param> /// <param name="groupIdToken">Additional identification token.</param> /// <param name="language1">The first optional preferred user interface language of identifier user.</param> /// <param name="language2">The second optional preferred user interface language of identifier user.</param> /// <param name="personalMessage">An optional message to be displayed at a charging station.</param> /// <param name="customData">An optional custom data object to allow to store any kind of customer specific data.</param> public IdTokenInfo(AuthorizationStatus status = AuthorizationStatus.Unknown, int chargingPriority = 0, DateTime?cacheExpiryDateTime = null, ICollection <int> evseIds = null, IdToken groupIdToken = null, string language1 = null, string language2 = null, MessageContent personalMessage = null, CustomData customData = null) { Status = status; ChargingPriority = chargingPriority; CacheExpiryDateTime = cacheExpiryDateTime; EvseIds = evseIds ?? new int[0]; GroupIdToken = groupIdToken; Language1 = language1; Language2 = language2; PersonalMessage = personalMessage; CustomData = customData; }
public void OnAuthorizationStatusFetched(AuthorizationStatus status) { switch (status) { case AuthorizationStatus.Authorized: break; default: resultText.text = "Cannot use Speech Recognition, authorization status is " + status; break; } }
public AuthorizationResult(TAccount account, AuthorizationStatus status, string errorDescription, IDictionary <string, string> additionalHeaders = null) { // For internal checks if (status == AuthorizationStatus.Ok) { throw new ArgumentException("Error description provided, but status is OK"); } Account = account; Status = status; ErrorDescription = errorDescription; AdditionalHeaders = additionalHeaders; }
internal AuthorizationResult(AuthorizationStatus status, string returnedUriInput) { this.Status = status; if (this.Status == AuthorizationStatus.UserCancel) { this.Error = AdalError.AuthenticationCanceled; this.ErrorDescription = AdalErrorMessage.AuthenticationCanceled; } else { this.ParseAuthorizeResponse(returnedUriInput); } }
internal AuthorizationResult(AuthorizationStatus status, string returnedUriInput):this(status) { if (this.Status == AuthorizationStatus.UserCancel) { this.Error = MsalError.AuthenticationCanceled; this.ErrorDescription = MsalErrorMessage.AuthenticationCanceled; } else if (this.Status == AuthorizationStatus.UnknownError) { this.Error = MsalError.Unknown; this.ErrorDescription = MsalErrorMessage.Unknown; } else { this.ParseAuthorizeResponse(returnedUriInput); } }
private void SetStatus(string type, String name, String authorizationKey, AuthorizationStatus status) { var key = GetKeyInternal(authorizationKey, true); var cacheKey = String.Format("{0}:{1}:{2}", type, name, authorizationKey); var model = GetModel(type, name, authorizationKey, true); model.Status = status; if (_store.Save(model)) this._cache[cacheKey] = status; }
private void VerifyCredentialsWithTwitter() { AuthorizationStatus = AuthorizationStatus.Verifying; var service = new TwitterService(_applicationCredentials.ConsumerKey, _applicationCredentials.ConsumerSecret, _accessToken.Token, _accessToken.TokenSecret); TwitterUser profile = service.VerifyCredentials(); AuthorizationStatus = profile != null ? AuthorizationStatus.Authorized : AuthorizationStatus.Unauthorized; AuthenticatedUser = profile != null ? _userFactory(profile) : null; }
private void ClientAuthorizationStatusChangesTo(AuthorizationStatus authorizationStatus) { _client.AuthorizationStatus.Returns(authorizationStatus); _client.PropertyChanged += Raise.Event<PropertyChangedEventHandler>(new PropertyChangedEventArgs("AuthorizationStatus")); }
public override ProtobufPacket ReadPacket(ProtobufDataReader reader) { AuthorizationStatus = (AuthorizationStatus) reader.Read((byte) AuthorizationStatus); return this; }
internal AuthorizationResult(AuthorizationStatus status) { this.Status = status; }
public TwitterAuthEventArgs(AuthorizationStatus newStatus) { this.newStatus = newStatus; }
private void ClientAuthorizationStatusChangesTo(AuthorizationStatus status) { _authorizer.PropertyChanges(x => x.AuthorizationStatus, status); }
private void VerifyCredentialsWithTwitter() { AuthorizationStatus = AuthorizationStatus.Verifying; ITwitterAccountVerifyCredentials twitter = FluentTwitter. CreateRequest(). AuthenticateWith(_credentials.ConsumerKey, _credentials.ConsumerSecret, _credentials.Token, _credentials.TokenSecret). Account(). VerifyCredentials(); TwitterResult response = twitter.Request(); TwitterUser profile = response.AsUser(); AuthorizationStatus = profile != null ? AuthorizationStatus.Authorized : AuthorizationStatus.NotAuthorized; }
private void CheckCredentials() { if (_credentials.AreValid) VerifyCredentialsWithTwitter(); else AuthorizationStatus = AuthorizationStatus.NotAuthorized; }
public void SetRoleStatus(string rolename, string authorizationKey, AuthorizationStatus status) { SetStatus("role", rolename, authorizationKey, status); }
public void SetUserStatus(string username, string authorizationKey, AuthorizationStatus status) { SetStatus("user", username, authorizationKey, status); }