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);
}
