Ejemplo n.º 1
0
        //Example call: Authenticate("DirectoryV.3", "myDomain.com", "myUser);

        public static AuthenticatedUserInfo Authenticate(AuthenticatedUserInfo AuthUserInfo, ClientSecrets Secrets,
                                                         string Domain = null, string User = null)
        {
            _currentAuthInfo = GetAuthTokenFlow(AuthUserInfo, Secrets);

            return(currentAuthInfo);
        }
Ejemplo n.º 2
0
        /// <summary>Retrieve an authentication token from memory or from user authentication.</summary>
        /// <remarks>Also fills out the OAuth2Base currentAuthInfo and asyncUserCredential members.</remarks>
        public static AuthenticatedUserInfo GetAuthTokenFlow(AuthenticatedUserInfo AuthUserInfo, ClientSecrets Secrets,
                                                             bool force = false)
        {
            //reset the auth info
            _currentAuthInfo = new AuthenticatedUserInfo()
            {
                scopes = AuthUserInfo.scopes, apiNameAndVersion = AuthUserInfo.apiNameAndVersion
            };

            //First, if the domain or user are missing, see if we can fill it in using the defaults
            AuthUserInfo.domain = CheckDomain(AuthUserInfo.domain);
            if (AuthUserInfo.domain != null)
            {
                AuthUserInfo.userName = CheckUser(AuthUserInfo.domain, AuthUserInfo.userName);
            }

            //First, if we are able to load a key based on the domain and user, we do that and add it to the data store.
            // This will make sure that when we authenticate, the Google Flow has something to load.
            if (AuthUserInfo.userName != null && AuthUserInfo.domain != null && infoConsumer.TokenAndScopesExist(
                    AuthUserInfo.domain, AuthUserInfo.userName, AuthUserInfo.apiNameAndVersion) && !force)
            {
                OAuth2TokenInfo preTokenInfo = infoConsumer.GetTokenInfo(AuthUserInfo.domain, AuthUserInfo.userName, AuthUserInfo.apiNameAndVersion);

                _currentAuthInfo.tokenResponse = preTokenInfo.token;
                _currentAuthInfo.tokenString   = preTokenInfo.tokenString;
                _currentAuthInfo.scopes        = preTokenInfo.scopes; //overwrite any coming in with what is saved
            }

            //Set the domain and user now, and we'll check them again later while we authorize.
            _currentAuthInfo.domain   = AuthUserInfo.domain;
            _currentAuthInfo.userName = AuthUserInfo.userName;

            _IsAuthenticating = true;

            //Populate asyncUserCredential, but we don't quite save the token yet...
            AwaitUserCredential(AuthUserInfo.scopes, Secrets).Wait();

            _IsAuthenticating = false;

            if (AuthTokenTempSwap != null)
            {
                //Now that we have asyncUserCredential filled out, we can actually save the token if we need to.
                memoryObjectDataStore.StoreAsync <TokenResponse>(string.Empty, AuthTokenTempSwap).Wait();
                AuthTokenTempSwap = null;
            }

            //The scopes, domain, user and api have already been set above. the token is set while saving.
            return(currentAuthInfo);
        }
Ejemplo n.º 3
0
        //public static BaseClientService.Initializer GetInitializer(Google.Apis.Http.IConfigurableHttpClientInitializer credentials)
        //{
        //    gInitializer initializer = new gInitializer()
        //    {
        //        HttpClientInitializer = credentials,
        //        ApplicationName = _appName,
        //    };

        //    return initializer;
        //}

        /// <summary>
        /// Returns an initializer used to create a new service.
        /// </summary>
        public static BaseClientService.Initializer GetInitializer(string AppName, AuthenticatedUserInfo authInfo, string serviceAccountUser = null)
        {
            //for non admin APIs, we need a service account
            //TODO: add in a default option to allow users to default to the DiscoveryInitializer anyways, if they want
            //if (authInfo.apiNameAndVersion.Contains("gmail")
            //    || authInfo.apiNameAndVersion.Contains("drive"))
            if (string.IsNullOrWhiteSpace(serviceAccountUser))
            {
                return(GetDiscoveryInitializer(AppName, authInfo));
            }
            else
            {
                return(GetServiceInitializer(AppName, authInfo, serviceAccountUser));
            }
        }
Ejemplo n.º 4
0
        public static BaseClientService.Initializer GetServiceInitializer(string appName, AuthenticatedUserInfo authInfo, string serviceAccountUser)
        {
            var serviceAccount = infoConsumer.GetServiceAccount(authInfo.domain);

            var scopes = authInfo.scopes;

            ////TODO: this has to match exactly what the service account has been authorized for, and nothing more!
            //if (authInfo.apiNameAndVersion.Contains("gmail"))
            //{
            //    scopes = new string[] { "https://mail.google.com/" };
            //}
            //else if (authInfo.apiNameAndVersion.Contains("drive"))
            //{
            //    scopes = new string[] { "https://www.googleapis.com/auth/drive" };
            //}

            ServiceAccountCredential credential = null;

            if (serviceAccount.certType == OAuth2Domain.CertTypeEnum.json)
            {
                credential = new ServiceAccountCredential(
                    new ServiceAccountCredential.Initializer(serviceAccount.email)
                {
                    User   = serviceAccountUser,
                    Scopes = scopes
                }.FromPrivateKey(serviceAccount.privateKey));
            }
            else
            {
                credential = new ServiceAccountCredential(
                    new ServiceAccountCredential.Initializer(serviceAccount.email)
                {
                    User   = serviceAccountUser,
                    Scopes = scopes
                }.FromCertificate(serviceAccount.certificate));
            }

            var init = new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName       = appName,
            };

            return(init);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Returns an initializer used to create a new service for GData APIs.
        /// </summary>
        public static BaseClientService.Initializer GetGdataInitializer(string AppName, AuthenticatedUserInfo authInfo)
        {
            gXmlInitializer initializer = new gXmlInitializer()
            {
                HttpClientInitializer = asyncUserCredential,
                ApplicationName       = AppName,
                //GZipEnabled = false
            };

            return(initializer);
        }
Ejemplo n.º 6
0
        public static BaseClientService.Initializer GetDiscoveryInitializer(string AppName, AuthenticatedUserInfo authInfo)
        {
            gJsonInitializer initializer = new gJsonInitializer()
            {
                HttpClientInitializer = asyncUserCredential,
                ApplicationName       = AppName,
            };

            return(initializer);
        }