public async Task <ClientSecretValidationResult> ValidateAsync()
        {
            Logger.Debug("Start client validation");

            var fail = new ClientSecretValidationResult
            {
                IsError = true
            };

            var parsedSecret = await _parser.ParseAsync(_environment.Environment);

            if (parsedSecret == null)
            {
                await RaiseFailureEvent("unknown", "No client id found");

                Logger.Info("No client secret found");
                return(fail);
            }

            // load client
            var client = await _clients.FindClientByIdAsync(parsedSecret.Id);

            if (client == null)
            {
                await RaiseFailureEvent(parsedSecret.Id, "Unknown client");

                Logger.Info("No client with that id found. aborting");
                return(fail);
            }

            if (!client.RequireClientSecret)
            {
                Logger.Debug("Public Client - skipping secret validation success");
            }
            else
            {
                var result = await _validator.ValidateAsync(parsedSecret, client.ClientSecrets);

                if (result.Success == false)
                {
                    await RaiseFailureEvent(client.ClientId, "Invalid client secret");

                    Logger.Info("Client validation failed.");

                    return(fail);
                }
            }

            Logger.Info("Client validation success");

            var success = new ClientSecretValidationResult
            {
                IsError = false,
                Client  = client
            };

            await RaiseSuccessEvent(client.ClientId);

            return(success);
        }
        public async Task <ScopeSecretValidationResult> ValidateAsync()
        {
            Logger.Debug("Start scope validation");

            var fail = new ScopeSecretValidationResult
            {
                IsError = true
            };

            var parsedSecret = await _parser.ParseAsync(_environment.Environment);

            if (parsedSecret == null)
            {
                await RaiseFailureEvent("unknown", "No scope id or secret found");

                Logger.Info("No scope secret found");
                return(fail);
            }

            // load scope
            var scope = (await _scopes.FindScopesAsync(new[] { parsedSecret.Id })).FirstOrDefault();

            if (scope == null)
            {
                await RaiseFailureEvent(parsedSecret.Id, "Unknown scope");

                Logger.Info("No scope with that name found. aborting");
                return(fail);
            }

            var result = await _validator.ValidateAsync(parsedSecret, scope.ScopeSecrets);

            if (result.Success)
            {
                Logger.Info("Scope validation success");

                var success = new ScopeSecretValidationResult
                {
                    IsError = false,
                    Scope   = scope
                };

                await RaiseSuccessEvent(scope.Name);

                return(success);
            }

            await RaiseFailureEvent(scope.Name, "Invalid client secret");

            Logger.Info("Scope validation failed.");

            return(fail);
        }