/**
  * Performs an OAuth authentication
  */
 public function execute()
 {
     /** @var \Grav\Common\Language\Language */
     $t = $this->grav['language'];
     $provider = strtolower($this->action);
     $config = $this->grav['config']->get('plugins.login.oauth.providers.' . $this->action, []);
     if (isset($config['credentials'])) {
         // Setup the credentials for the requests
         $credentials = new Credentials($config['credentials']['key'], $config['credentials']['secret'], $this->grav['uri']->url(true));
         // Instantiate service using the credentials, http client
         // and storage mechanism for the token
         $scope = isset($this->scopes[$provider]) ? $this->scopes[$provider] : [];
         $this->service = $this->factory->createService($this->action, $credentials, $this->storage, $scope);
     }
     if (!$this->service || empty($config)) {
         $this->setMessage($t->translate(['LOGIN_PLUGIN.OAUTH_PROVIDER_NOT_SUPPORTED', $this->action]));
         return true;
     }
     // Check OAuth authentication status
     $authenticated = parent::execute();
     if (is_bool($authenticated)) {
         $this->reset();
         if ($authenticated) {
             $this->setMessage($t->translate('LOGIN_PLUGIN.LOGIN_SUCCESSFUL'));
         } else {
             $this->setMessage($t->translate('LOGIN_PLUGIN.ACCESS_DENIED'));
         }
         // Redirect to current URI
         $referrer = $this->grav['uri']->url(true);
         $this->setRedirect($referrer);
     } elseif (!$this->grav['session']->oauth) {
         $this->setMessage($t->translate(['LOGIN_PLUGIN.OAUTH_PROVIDER_NOT_SUPPORTED', $this->action]));
     }
     return true;
 }
 public static function create(string $service) : AbstractProvider
 {
     // persistent storage to save the token
     $storage = new SessionStorage();
     // Setup the credentials for the requests
     $credentials = new Credentials(DI::config()->get('socials/' . $service . '/key'), DI::config()->get('socials/' . $service . '/secret'), self::uri('oauth/end', ['service' => $service])->get(false));
     // Oauth Service
     $serviceFactory = new ServiceFactory();
     $serviceFactory->setHttpClient(new HttpClient());
     $class = 'Cawa\\Oauth\\Providers\\' . ucfirst($service);
     /** @var AbstractProvider $provider */
     $provider = new $class();
     $provider->type = $service;
     // scope
     $scopes = DI::config()->getIfExists('socials/' . $service . '/scopes');
     if (!$scopes && defined($class . '::DEFAULT_SCOPES')) {
         $scopes = constant($class . '::DEFAULT_SCOPES');
     }
     if (!$scopes) {
         $scopes = [];
     }
     // version
     $version = null;
     if (defined($class . '::API_VERSION')) {
         $version = constant($class . '::API_VERSION');
     }
     $service = $serviceFactory->createService($service, $credentials, $storage, $scopes, null, $version);
     $provider->service = $service;
     return $provider;
 }
 /**
  * Constructor
  *
  * @param $url
  */
 public function __construct($url)
 {
     $this->hlp = plugin_load('helper', 'oauth');
     $credentials = new Credentials($this->hlp->getKey($this->getAdapterName()), $this->hlp->getSecret($this->getAdapterName()), $url);
     $this->storage = new oAuthStorage();
     $serviceFactory = new ServiceFactory();
     $serviceFactory->setHttpClient(new oAuthHTTPClient());
     $this->oAuth = $serviceFactory->createService($this->getServiceName(), $credentials, $this->storage, $this->getScope());
 }
 protected function buildDefaultAuthenticator($clientID, $clientSecret, $callbackUrl)
 {
     $credentials = new Credentials($clientID, $clientSecret, $callbackUrl);
     $facotry = new ServiceFactory();
     $session = new Session();
     $service = $facotry->createService('wunderlist', $credentials, $session);
     $request = Request::createFromGlobals();
     return new OAuthLibAuthentication($service, $request);
 }
Beispiel #5
0
 /**
  * Get the GitHub service instance
  *
  * @access public
  * @return \OAuth\OAuth2\Service\GitHub
  */
 public function getService()
 {
     $uriFactory = new UriFactory();
     $currentUri = $uriFactory->createFromSuperGlobalArray($_SERVER);
     $currentUri->setQuery('controller=user&action=gitHub');
     $storage = new Session(false);
     $credentials = new Credentials(GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET, $currentUri->getAbsoluteUri());
     $serviceFactory = new ServiceFactory();
     return $serviceFactory->createService('gitHub', $credentials, $storage, array(''));
 }
Beispiel #6
0
 /**
  * Get the Google service instance
  *
  * @access public
  * @return \OAuth\OAuth2\Service\Google
  */
 public function getService()
 {
     $uriFactory = new UriFactory();
     $currentUri = $uriFactory->createFromSuperGlobalArray($_SERVER);
     $currentUri->setQuery('controller=user&action=google');
     $storage = new Session(false);
     $credentials = new Credentials(GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, $currentUri->getAbsoluteUri());
     $serviceFactory = new ServiceFactory();
     return $serviceFactory->createService('google', $credentials, $storage, array('userinfo_email', 'userinfo_profile'));
 }
 /**
  * @param $id
  * @return \OAuth\OAuth2\Service\AbstractService
  */
 protected function getService($id)
 {
     $credential = $this->getCredentials($id);
     // Setup the credentials for the requests
     $credentials = new Credentials($credential['id'], $credential['secret'], $this->getRootUri() . $this->getCallbackPath($id));
     $serviceFactory = new ServiceFactory();
     $serviceFactory->registerService('IsseHom', '\\Paliari\\Oauth2ClientFacade\\IsseHom');
     $serviceFactory->registerService('IssePro', '\\Paliari\\Oauth2ClientFacade\\IssePro');
     $service = $serviceFactory->createService($id, $credentials, $this->getStorage(), $credential['scopes']);
     return $service;
 }
Beispiel #8
0
 public function init()
 {
     if (isset($this->service)) {
         return;
     }
     $serviceFactory = new ServiceFactory();
     // Session storage
     $storage = new Session();
     // Setup the credentials for the requests
     $credentials = new Credentials($this->clientId, $this->clientSecret, Url::modify($this->redirectUrl, Url::ABS));
     $this->service = $serviceFactory->createService('facebook', $credentials, $storage, $this->scopes);
 }
Beispiel #9
0
 public function getContent()
 {
     $serviceFactory = new ServiceFactory();
     $storage = new OauThSession();
     $credentials = new Credentials(Config::get('google.key'), Config::get('google.secret'), URLSITE . 'google/auth');
     $googleService = $serviceFactory->createService('google', $credentials, $storage, array('userinfo_email', 'userinfo_profile'));
     $state = isset($_GET['state']) ? $_GET['state'] : null;
     // This was a callback request from google, get the token
     $googleService->requestAccessToken($_GET['code'], $state);
     // Send a request with it
     return json_decode($googleService->request('userinfo'), true);
 }
Beispiel #10
0
 public function init()
 {
     if (isset($this->service)) {
         return;
     }
     $serviceFactory = new ServiceFactory();
     // Session storage
     $storage = new Session(false);
     // Setup the credentials for the requests
     $credentials = new Credentials($this->clientId, $this->clientSecret, Url::modify($this->redirectUrl, Url::ABS));
     // Instantiate the Google service using the credentials, http client and storage mechanism for the token
     $this->service = $serviceFactory->createService('google', $credentials, $storage, $this->scopes);
 }
Beispiel #11
0
 /**
  * @param Application $app
  * @param Request $request
  * @param string $service
  * 
  * @return string
  */
 public function auth(Application $app, Request $request, $service)
 {
     // Construir los servicios
     $serviceFactory = new ServiceFactory();
     // Almacenamiento en session
     $storage = new Session();
     // Obtener credenciales
     $servicesCredentials = SocialsCredentials::getArrayCredentials();
     $url = $app['url_generator']->generate('auth_service', array('service' => $service), UrlGenerator::ABSOLUTE_URL);
     if ($service == 'facebook') {
         // Credenciales de facebook
         $facebookCredentials = new Credentials($servicesCredentials['facebook']['key'], $servicesCredentials['facebook']['secret'], $url);
         // Servicio de auth de facebook
         $serviceAuth = $serviceFactory->createService('facebook', $facebookCredentials, $storage, array());
     } else {
         if ($service == 'google') {
             // Credenciales de google
             $googleCredentials = new Credentials($servicesCredentials['google']['key'], $servicesCredentials['google']['secret'], $url);
             // Servicio de auth de google
             $serviceAuth = $serviceFactory->createService('google', $googleCredentials, $storage, array('userinfo_email', 'userinfo_profile'));
         }
     }
     $menuModelo = new Menu($app['db']);
     $menuItems = $menuModelo->getItems();
     if ($request->get('code') && $service == 'facebook') {
         try {
             // Callback de facebook para obtener el access token
             $serviceAuth->requestAccessToken($request->get('code'));
         } catch (TokenResponseException $ex) {
         }
         // Se adquiere la informacion del usuario
         $usuario = json_decode($serviceAuth->request('/me'), true);
         $usuario['service'] = 'facebook';
         return $app['twig']->render('frontend/usuario/signup.html.twig', array('menu_items' => $menuItems, 'usuario' => $usuario));
     } else {
         if ($request->get('code') && $service == 'google') {
             try {
                 // Callback de google para obtener el access token
                 $serviceAuth->requestAccessToken($request->get('code'));
             } catch (TokenResponseException $ex) {
             }
             // Se adquiere la informacion del usuario
             $usuario = json_decode($serviceAuth->request('https://www.googleapis.com/oauth2/v1/userinfo'), true);
             $usuario['service'] = 'google';
             return $app['twig']->render('frontend/usuario/signup.html.twig', array('menu_items' => $menuItems, 'usuario' => $usuario));
         } else {
             return "<script> location.href = '{$serviceAuth->getAuthorizationUri()}'; </script>";
         }
     }
 }
Beispiel #12
0
 /**
  * Return an instance of the requested service.
  *
  * @param string $provider
  * @param string $url
  * @param array  $scope
  * 
  * @return \OAuth\Common\Service\AbstractService
  * @throws \Exception
  */
 public function service($provider, $url = null, $scope = null)
 {
     $info = Config::get('laravel-social::providers.' . strtolower($provider));
     if (empty($info) || !is_array($info)) {
         throw new Exception('Missing configuration details for Social service: ' . $provider);
     }
     $client_id = array_get($info, 'client_id');
     $client_secret = array_get($info, 'client_secret');
     $scope = is_null($scope) ? array_get($info, 'scope') : $scope;
     if (empty($client_id) || empty($client_secret)) {
         throw new Exception('Missing client id/secret for Social service: ' . $provider);
     }
     return $this->factory->createService(ucfirst($provider), new Credentials($client_id, $client_secret, $url ?: URL::current()), $this->storage, $scope);
 }
 function it_allows_for_dynamic_calls_to_providers_methods_with_the_given_decorator(Repository $config, ServiceFactory $serviceFactory)
 {
     $serviceFactory->createService('Foo', Argument::type(self::INTERFACE_CREDENTIALS), Argument::type(self::INTERFACE_STORAGE))->shouldBeCalledTimes(1)->willReturn(new Foo());
     $config->has('oauth.providers.Foo')->willReturn(true);
     $config->has('oauth.providers.Foo.class')->willReturn(false);
     $config->has('oauth.providers.Foo.decorators')->willReturn(true);
     $config->get('oauth.providers.Foo.decorators')->willReturn(['tests\\Pasadinhas\\LaravelOAuth\\Decorator1', 'tests\\Pasadinhas\\LaravelOAuth\\Decorator2']);
     $config->get('oauth.providers.Foo.consumer_key')->willReturn('foo');
     $config->get('oauth.providers.Foo.consumer_secret')->willReturn('bar');
     $config->get('oauth.providers.Foo.callback_url')->willReturn('http://baz.com/login');
     $foo = $this->make('Foo');
     $foo->testDynamicMethods1()->shouldReturn('1');
     $foo->testDynamicMethods2()->shouldReturn('2');
 }
 public function register()
 {
     $this->app->bind('oauth/factory/service', function ($app, $params = array()) {
         $factory = new ServiceFactory();
         $factory->setHttpClient($client = new CurlClient());
         $client->setCurlParameters((array) $params);
         return $factory;
     });
     $this->app->bindShared('oauth/factory/extractor', function () {
         return new ExtractorFactory();
     });
     $this->app->bind('oauth_extractor', function ($app, $params = array()) {
         if (!is_array($params)) {
             $params = array($params);
         }
         if (!($service = head($params))) {
             throw new \InvalidArgumentException('No Service given.');
         }
         $extractor_factory = $app->make('oauth/factory/extractor');
         return $extractor_factory->get($service);
     });
     \Route::register('/ccm/system/authentication/oauth2/{type}/{action}', function ($type, $action) {
         try {
             $type = \AuthenticationType::getByHandle($type);
             if ($type && is_object($type) && !$type->isError()) {
                 /** @var GenericOauthTypeController $controller */
                 $controller = $type->getController();
                 if ($controller instanceof GenericOauthTypeController) {
                     switch ($action) {
                         case 'attempt_auth':
                             return $controller->handle_authentication_attempt();
                             break;
                         case 'callback':
                             return $controller->handle_authentication_callback();
                             break;
                         case 'attempt_attach':
                             return $controller->handle_attach_attempt();
                             break;
                         case 'attach_callback':
                             return $controller->handle_attach_callback();
                             break;
                     }
                 }
             }
         } catch (\Exception $e) {
             \Log::addNotice('OAUTH ERROR: ' . $e->getMessage());
         }
     });
 }
Beispiel #15
0
 /**
  * Get the Flickr service.
  * @return AbstractService
  */
 public function getService()
 {
     //      if ( $this->flickrService instanceof ServiceInterface ) {
     //          return $this->flickrService;
     //      }
     $credentials = new Credentials($this->apiKey, $this->apiSecret, 'oob');
     $storage = new Memory();
     $accessToken = $this->getStoredCredentials();
     if ($accessToken instanceof TokenInterface) {
         $storage->storeAccessToken('Flickr', $accessToken);
     }
     $serviceFactory = new ServiceFactory();
     $this->flickrService = $serviceFactory->createService('Flickr', $credentials, $storage);
     return $this->flickrService;
 }
Beispiel #16
0
 /**
  * @param $resourceOwnerName
  * @return \OAuth\Common\Service\ServiceInterface
  * @throws Exception
  */
 public function createService($resourceOwnerName)
 {
     if (!isset(ResourceOwners::$all[$resourceOwnerName])) {
         throw new Exception('Resource owner ' . $resourceOwnerName . ' is not available');
     }
     if (isset($this->serviceCache[$resourceOwnerName])) {
         return $this->serviceCache[$resourceOwnerName];
     }
     $lowerResourceOwnerName = $string = strtolower(preg_replace('/(?<=\\w)(?=[A-Z])/', "_\$1", $resourceOwnerName));
     $paramName = 'apinnecke_oauth.resource_owners.' . $lowerResourceOwnerName . '.callback_url';
     if (!$this->container->hasParameter($paramName) || !($callbackUrl = $this->container->getParameter($paramName)) || null === $callbackUrl) {
         $callbackUrl = $this->container->get('router')->getContext()->getBaseUrl();
     }
     $credentials = new Credentials($this->container->getParameter('apinnecke_oauth.resource_owners.' . $lowerResourceOwnerName . '.client_id'), $this->container->getParameter('apinnecke_oauth.resource_owners.' . $lowerResourceOwnerName . '.client_secret'), $callbackUrl);
     return $this->serviceCache[$resourceOwnerName] = $this->factory->createService($resourceOwnerName, $credentials, $this->storage);
 }
Beispiel #17
0
 protected function init($callbackUrl = null)
 {
     if (!$this->init) {
         if (!$this->storage) {
             $this->storage = new Session();
         }
         $uriFactory = new UriFactory();
         $this->currentUri = $uriFactory->createFromSuperGlobalArray($_SERVER);
         $credentials = new Credentials($this->apiKey, $this->apiSecret, $callbackUrl ? $callbackUrl : $this->currentUri->getAbsoluteUri());
         $serviceFactory = new ServiceFactory();
         $serviceFactory->setHttpClient(new CurlClient());
         $serviceFactory->registerService('DoYouBuzz', 'DoYouBuzz\\ApiHelper\\DoYouBuzzService');
         $this->service = $serviceFactory->createService('DoYouBuzz', $credentials, $this->storage);
         $this->init = true;
     }
 }
Beispiel #18
0
 /**
  * Set the HTTP client.
  *
  * @param string $client
  */
 public function setHttpClient($client)
 {
     if (!in_array($client, ['StreamClient', 'CurlClient'])) {
         throw new \InvalidArgumentException('Invalid HTTP client');
     }
     $class = '\\OAuth\\Common\\Http\\Client\\' . $client;
     $this->factory->setHttpClient(new $class());
 }
Beispiel #19
0
 /**
  * Check the authentication. Will be called two times : first to request a token, and redirect
  * to the Twitter api url, then to authenticate the user.
  *
  * @param  [type] $request [description]
  * @param  array  $options [description]
  * @return [type]          [description]
  */
 public function check($request, array $options = array())
 {
     $here = new Uri($request->to('url'));
     $here->setQuery('');
     $credentials = new Credentials($this->_config['key'], $this->_config['secret'], $here->getAbsoluteUri());
     $serviceFactory = new ServiceFactory();
     $service = $serviceFactory->createService(static::NAME, $credentials, $this->_storage, $this->_config['scope']);
     if (empty($request->query['code'])) {
         $url = $service->getAuthorizationUri();
         header('Location: ' . $url);
         exit(0);
     } else {
         $service->requestAccessToken($request->query['code']);
         $result = json_decode($service->request(static::USER_INFO), true);
         return $result;
     }
 }
Beispiel #20
0
 /**
  * Check the authentication. Will be called two times : first to request a token, and redirect
  * to the Twitter api url, then to authenticate the user.
  *
  * @param  [type] $request [description]
  * @param  array  $options [description]
  * @return [type]          [description]
  */
 public function check($request, array $options = array())
 {
     $credentials = new Credentials($this->_config['key'], $this->_config['secret'], $request->to('url'));
     $serviceFactory = new ServiceFactory();
     $service = $serviceFactory->createService('twitter', $credentials, $this->_storage);
     if (!empty($request->query['denied'])) {
         return false;
     } elseif (empty($request->query['oauth_token'])) {
         $token = $service->requestRequestToken();
         $url = $service->getAuthorizationUri(array('oauth_token' => $token->getRequestToken()));
         header('Location: ' . $url);
     } else {
         $token = $this->_storage->retrieveAccessToken('Twitter');
         $service->requestAccessToken($request->query['oauth_token'], $request->query['oauth_verifier'], $token->getRequestTokenSecret());
         $result = json_decode($service->request('account/verify_credentials.json'), true);
         return $result;
     }
 }
 /**
  * Create a service object given a ServiceFactory object
  *
  * @param \OAuth\ServiceFactory $factory
  * @return \OAuth\Common\Service\ServiceInterface
  */
 public function createService(ServiceFactory $factory)
 {
     $appId = $this->config->get('auth.community.appid');
     $appSecret = $this->config->get('auth.community.secret');
     // Get the callback url
     /** @var Url $callbackUrl */
     $callbackUrl = $this->urlResolver->resolve(['/ccm/system/authentication/oauth2/community/callback/']);
     if ($callbackUrl->getHost() == '') {
         $callbackUrl = $callbackUrl->setHost($this->request->getHost());
         $callbackUrl = $callbackUrl->setScheme($this->request->getScheme());
     }
     // Create a credential object with our ID, Secret, and callback url
     $credentials = new Credentials($appId, $appSecret, (string) $callbackUrl);
     // Create a new session storage object and pass it the active session
     $storage = new SymfonySession($this->session, false);
     // Create the service using the oauth service factory
     return $factory->createService('community', $credentials, $storage);
 }
 /**
  * Set extra providers based on the configuration settings
  */
 protected function setExtraProviders()
 {
     $providers = Config::get('oauth::extra_providers');
     if (!$providers) {
         return;
     }
     foreach ($providers as $name => $class) {
         $this->serviceFactory->registerService($name, $class);
     }
 }
 /**
  * @param  string $service
  * @param  array $credentials
  * @param  string $url
  * @param  array $scope
  *
  * @return \OAuth\Common\Service\AbstractService
  */
 protected function consumer($service, $credentials = array(), $url = null, $scope = null)
 {
     if (!empty($this->oauth)) {
         return $this->oauth;
     }
     $scope = array_get($credentials, "scope", []);
     // get storage object
     $storage = $this->createStorageInstance($this->storageClass);
     // return the service consumer object
     $this->oauth = $this->serviceFactory->createService($service, $this->getCredentials($credentials, $url), $storage, $scope);
     return $this->oauth;
 }
Beispiel #24
0
 /**
  * Creates a Connector object for the given provider type. The $id parameter
  * may be null but should only be used like that when getting
  *
  * @param  string $provider The provider type you want.
  * @param  TokenStorageInterface $storage The storage for PHPoAuthLib.
  * @param  array $options
  * @param  string $id The ID we're connecting to.
  * @param  null|ClientInterface $http_client The HTTP client for PHPoAuthLib.
  * @param  null|ServiceFactory $service_factory The PHPoAuthLib service factory.
  * @param  null|CredentialsInterface $credentials The credentials for PHPoAuthLib.
  * @return ConnectorInterface An instance of the requested connector type.
  * @throws InvalidProviderException
  */
 public function createConnector($provider, TokenStorageInterface $storage, array $options = [], $id = null, ClientInterface $http_client = null, ServiceFactory $service_factory = null, CredentialsInterface $credentials = null)
 {
     // Only allow configured providers.
     if (!array_key_exists($provider, $this->config['providers'])) {
         throw new InvalidProviderException($provider);
     }
     // Default to CurlClient (why isn't this the default? :( )
     if (is_null($http_client)) {
         $http_client = new CurlClient();
     }
     // Just if we want to be lazy and not pass this as an argument.
     if (is_null($service_factory)) {
         $service_factory = new ServiceFactory();
     }
     // Simplify config access for this provider.
     $config = $this->getFlatConfig($provider);
     // We're already getting the credentials via $this->config, we might not
     // want to always pass them as an argument.
     if (is_null($credentials)) {
         $credentials = new Credentials($config['consumer_key'], $config['consumer_secret'], $config['callback']);
     }
     // Let's make use of CurlClient.
     $service_factory->setHttpClient($http_client);
     // Temporary (or so I hope) hack to overcome PHPoAuthLib not being ready
     // for Facebook's Graph API 1.0 deprecation.
     // If this is Facebook, let's specify we want API v2.2
     //        $api_version = null;
     //        if (strtolower($provider) == 'facebook') {
     //            $api_version = '2.2';
     //        }
     $uri = null;
     if (in_array($provider, ['Facebook', 'FacebookGroup', 'FacebookPage'])) {
         $uri = new Uri('https://graph.facebook.com/v2.2/');
     }
     // Finally, create the service already!
     $service = $service_factory->createService($config['service'], $credentials, $storage, $config['scopes'], $uri);
     $connector_class = '\\Borfast\\Socializr\\Connectors\\' . $provider;
     $connector = new $connector_class($config, $service, $options, $id);
     return $connector;
 }
Beispiel #25
0
 /**
  * Create and configure OAuth service object.
  * 
  * @param array $ini_data
  * @param object $payload
  * @throws ErrorException
  */
 public function __construct($ini_data, $payload)
 {
     $payload = $this->parsePayload($payload);
     $this->environment = $payload->env;
     $this->ini_data = $ini_data;
     if (!isset($this->ini_data[$this->environment])) {
         throw new ErrorException("No configuration data found for this environment: {$this->environment}\n");
     }
     if (isset($payload->authorization_code)) {
         $this->authorization_code = $payload->authorization_code;
     }
     $service_factory = new \OAuth\ServiceFactory();
     $session_storage = new Session();
     // Iron.io callback URL.
     // That will be used to pass authorization code back to the worker.
     $webhook_url = 'https://worker-aws-us-east-1.iron.io/2/projects/' . $this->getIniData('project_id') . '/tasks/webhook?code_name=' . $this->getIniData('worker_name') . '&oauth=' . $this->getIniData('token') . '&env=' . $this->environment;
     // Setup credentials for OAuth requests.
     $credentials = new Credentials($this->getIniData('username'), $this->getIniData('password'), $webhook_url);
     $api_uri = new Uri\Uri($this->getIniData('api_uri'));
     $this->service = $service_factory->createService('IronIoOAuthService', $credentials, $session_storage, array(), $api_uri);
     $this->service->setAuthorizationEndpoint($this->getIniData('oauth_auth_endpoint'));
     $this->service->setAccessTokenEndpoint($this->getIniData('oauth_token_endpoint'));
 }
Beispiel #26
0
 /**
  * @param  string $service
  * @param  string $url
  * @param  array  $scope
  *
  * @return \OAuth\Common\Service\AbstractService
  */
 public function consumer($service, $url = null, $scope = null)
 {
     // get config
     $this->setConfig($service);
     // get storage object
     $storage = $this->createStorageInstance($this->_storage_name);
     // create credentials object
     $credentials = new Credentials($this->_client_id, $this->_client_secret, $url ?: URL::current());
     // check if scopes were provided
     if (is_null($scope)) {
         // get scope from config (default to empty array)
         $scope = $this->_scope;
     }
     // return the service consumer object
     return $this->_serviceFactory->createService($service, $credentials, $storage, $scope);
 }
Beispiel #27
0
 /**
  * @param  string $service
  * @param  string $url
  * @param  array  $scope
  * @return \OAuth\Common\Service\AbstractService
  */
 public function consumer($service, $url = null, $scope = null, $uri = null, $client_id = null, $client_secret = null)
 {
     // get config
     $this->loadConfig($service);
     // create credentials object
     $credentials = new Credentials($client_id ?: $this->_client_id, $client_secret ?: $this->_client_secret, $url ?: URL::current());
     // check if scopes were provided
     if (is_null($scope)) {
         $scope = $this->_scope ? $this->_scope : array();
     }
     // check if uri were provided
     if (is_null($uri)) {
         $uri = $this->_uri ? $this->_uri : array();
     }
     $uri = new Uri($uri);
     // dd($uri);
     // return the service consumer object
     return $this->_serviceFactory->createService($service, $credentials, $this->_storage, $scope, $uri);
 }
Beispiel #28
0
 /**
  * @param  string $service
  * @param  string $url
  * @param  array  $scope
  * @return \OAuth\Common\Service\AbstractService
  */
 public function consumer($service, $baseUri = null, $user, $key = 'oauth_access_token', $stateKey = 'oauth_authorization_state', $url = null, $scope = null)
 {
     // get config
     $this->setConfig($service);
     // get storage object
     $storage = $this->createStorageInstance($this->_storage_name, $user, $key, $stateKey);
     // create credentials object
     $credentials = new Credentials($this->_client_id, $this->_client_secret, $url ?: URL::current());
     // check if scopes were provided
     if (is_null($scope)) {
         // get scope from config (default to empty array)
         $scope = $this->_scope;
     }
     if (!is_null($baseUri)) {
         $baseUri = new Uri($baseUri);
     }
     // return the service consumer object
     return $this->_serviceFactory->createService($service, $credentials, $storage, $scope, $baseUri);
 }
 /**
  * Retrieve a user by the given credentials.
  *
  * @param  array  $credentials
  * @return \Illuminate\Auth\UserInterface|null
  */
 public function retrieveByCredentials(array $credentials)
 {
     require_once base_path() . '/vendor/lusitanian/OAuth/bootstrap.php';
     $url = url('/');
     if (!empty($this->auth->oauthGoogleId) and !empty($this->auth->oauthGoogleSecret)) {
         // Setup the credentials for the requests
         $credentials = new Credentials($this->auth->oauthGoogleId, $this->auth->oauthGoogleSecret, url('user/login'));
         // Session storage
         $storage = new Session();
         // Instantiate the Google service using the credentials, http client and storage mechanism for the token
         $service = new ServiceFactory();
         $google = $service->createService('google', $credentials, $storage, array('userinfo_email', 'groups_provisioning'));
         // Google responded with a code
         if (Input::has('code')) {
             // This was a callback request from google, get the token
             $google->requestAccessToken(Input::get('code'));
             // Send a request with it
             $result = json_decode($google->request(Site::config('services')->googleUrlOAuth), TRUE);
             // Process user
             if (is_string($result['id']) and is_string($result['email']) and isset($result['verified_email'])) {
                 if ($result['verified_email']) {
                     // First we will add each credential element to the query as a where clause.
                     // Then we can execute the query and, if we found a user, return it in a
                     // Eloquent User "model" that will be utilized by the Guard instances.
                     $query = $this->createModel()->newQuery();
                     // We search by email and user type. A filter for type=oauth is added to avoid
                     // getting users created by other auth methods
                     $query->where('email', $result['email'])->where('type', 'oauth');
                     // If a user is not found, we need to create one automagically
                     // Thats why even if count is 0, we return a new model instance
                     $user = $query->count() > 0 ? $query->first() : $this->createModel();
                     // Determine if user is an admin
                     $googleAdmins = explode("\n", $this->auth->oauthGoogleAdmins);
                     $isAdmin = in_array($result['email'], $googleAdmins);
                     // We extract the username from the email address of the user
                     $parts = explode('@', $result['email']);
                     // Insert/Update user info
                     $user->username = $parts[0];
                     $user->password = '';
                     $user->salt = '';
                     $user->email = $result['email'];
                     $user->type = 'oauth';
                     $user->active = 1;
                     $user->admin = $isAdmin;
                     $user->save();
                     // Log the user in. We need to do it manually because we don't have an username
                     // that we can 'attempt' to log in.
                     Auth::login($user);
                     return $user;
                 }
             }
             App::abort(401);
             // Unauthorized
         } else {
             $url = $google->getAuthorizationUri()->getAbsoluteUri();
         }
     }
     App::after(function ($request, $response) use($url) {
         $response->headers->set('Location', $url);
     });
     return NULL;
 }
 /**
  * @covers OAuth\Common\Service\AbstractService::__construct
  * @covers OAuth\Common\Service\AbstractService::determineRequestUriFromPath
  */
 public function testDetermineRequestUriFromPathWithLeadingSlashInPath()
 {
     $service = new Mock($this->getMock('\\OAuth\\Common\\Consumer\\CredentialsInterface'), ServiceFactory::construct()->getHttpTransporter(), $this->getMock('\\OAuth\\Common\\Storage\\TokenStorageInterface'), 'https://example.com');
     $uri = $service->testDetermineRequestUriFromPath('/path');
     $this->assertInstanceOf('\\OAuth\\Common\\Http\\Url', $uri);
     $this->assertSame('https://example.com/path', (string) $uri);
 }