private IEnumerator OnReconnectedCoro()
        {
            // Re-authorize
            yield return(CoroutineManager.StartCoroutine(AuthorizationStrategy.RestoreAuthorization()));

            // Restore interrupted contexts
            yield return(CoroutineManager.StartCoroutine(RestoreInterruptedAuthorizationContext()));
        }
        public void Setup()
        {
            var application = new Application
            {
                ApplicationName = "IntegrationTests"
            };

            SetupContext.Applications.Add(application);

            var authorizationStrategy = new AuthorizationStrategy
            {
                Application = application,
                AuthorizationStrategyName = NoFurtherAuthorizationRequired.StrategyName,
                DisplayName = NoFurtherAuthorizationRequired.DisplayName
            };

            SetupContext.AuthorizationStrategies.Add(authorizationStrategy);

            SetupContext.SaveChanges();
        }
Example #3
0
        public static AuthorizationStrategy[] AddAuthorizationStrategyOverrides(this AuthorizationStrategy[] authorizationStrategies,
                                                                                Security.DataAccess.Models.Action action, AuthorizationStrategy strategy)
        {
            if (action.ActionName == Action.Create.Value)
            {
                authorizationStrategies[0] = strategy;
            }
            else if (action.ActionName == Action.Read.Value)
            {
                authorizationStrategies[1] = strategy;
            }
            else if (action.ActionName == Action.Update.Value)
            {
                authorizationStrategies[2] = strategy;
            }
            else if (action.ActionName == Action.Delete.Value)
            {
                authorizationStrategies[3] = strategy;
            }

            return(authorizationStrategies);
        }
        /// <summary>
        /// Closes the connection and yields (waits for it to be closed)
        /// </summary>
        public IEnumerator Close()
        {
            if (Authorized)
            {
                // End the root context
                if (_authorizationContext != null)
                {
                    EndAuthorizationContext();
                }

                // Force client to send the data to the server immidiately, ignore the ChunkLifeTime and chunk max length
                ResetActiveChunk();

                // Wait for the next ProcessBulkedRequests call to send the chunk - IF there is a net connection
                if (IsAvailable)
                {
                    yield return(CoroutineManager.StartCoroutine(WaitForAllChunksToBeProcessed()));
                }

                if (_processBulkRequestCoroutine != null)
                {
                    CoroutineManager.StopCoroutine(_processBulkRequestCoroutine);
                }

                if (_trackContextDataCoroutine != null)
                {
                    CoroutineManager.StopCoroutine(_trackContextDataCoroutine);
                }

                // Unsubscribe from events
                JsonRpcClient.OnLostConnection -= OnLostConnection;
                JsonRpcClient.OnReconnected    -= OnReconnected;

                // Reset Authorized on the AuthorizationStartategy
                AuthorizationStrategy.ResetAuthorization();
            }

            yield return(CoroutineManager.StartCoroutine(JsonRpcClient.Close()));
        }
 public virtual IEnumerator Authorize()
 {
     yield return(CoroutineManager.StartCoroutine(AuthorizationStrategy.Authorize()));
 }