public static async Task <TResult> IdentifyAccountAsync <TResult>(Authorization authorization,
                                                                          Method authenticationMethod, string externalAccountKey,
                                                                          IDictionary <string, string> extraParams,
                                                                          IAzureApplication application,
                                                                          IProvideLogin loginProvider,
                                                                          IHttpRequest request,
                                                                          Func <Guid, IDictionary <string, string>, TResult> onLocated,
                                                                          Func <Uri, Guid, IDictionary <string, string>, TResult> onInterupted,
                                                                          Func <string, TResult> onGeneralFailure,
                                                                          TelemetryClient telemetry)
        {
            if (!(application is IProvideAccountInformation))
            {
                authorization.authorized             = true;
                authorization.LocationAuthentication = null;
                // return await OnLegacy();
                return(onGeneralFailure($"{application.GetType().FullName} does not implement {nameof(IProvideAccountInformation)}."));
            }
            var accountInfoProvider = (IProvideAccountInformation)application;

            return(await accountInfoProvider.FindOrCreateAccountByMethodAndKeyAsync(
                       authenticationMethod, externalAccountKey,
                       authorization, extraParams,
                       loginProvider, request,
                       PopulateAccount,
                       onAccountReady : (internalAccountId, claims) =>
            {
                return onLocated(internalAccountId, claims);
            },
                       onInterceptProcess : (url, internalAccountId, claims) =>
            {
                return onInterupted(url, internalAccountId, claims);
            },
                       onReject : onGeneralFailure));

            IAccount PopulateAccount(IAccount account)
            {
                account.AccountLinks = new AccountLinks
                {
                    accountLinks = new AccountLink[]
                    {
                        new AccountLink()
                        {
                            externalAccountKey = externalAccountKey,
                            method             = authenticationMethod.authenticationId,
                        }
                    }
                };

                if (!(loginProvider is IProvideClaims))
                {
                    return(account);
                }
                var claimProvider = (IProvideClaims)loginProvider;

                var accountPopulatedFromClaims = claimProvider.PopulateResourceFromClaims(account, extraParams);

                return(accountPopulatedFromClaims);
            }
        }
Exemple #2
0
        public InvokeFunction(IAzureApplication application, Uri serverUrl, string apiRouteName, int executionLimit = 1)
            : base(serverUrl, apiRouteName)
        {
            IAzureApplication GetApplication()
            {
                if (application is FunctionApplication)
                {
                    return(application);
                }

                var newApp = Activator.CreateInstance(application.GetType()) as IAzureApplication;

                createdByThis = true;
                //newApp.ApplicationStart();

                return(newApp);
            }

            this.azureApplication = application; //  GetApplication();
            this.executionLimit   = executionLimit;
        }