PHP FacebookSession::validate方法代码示例

 /**
  * @param string $accessToken
  *
  * @throws FacebookException
  */
 public function connect($accessToken)
 {
     $this->session = new FacebookSession($accessToken);
     try {
         $this->session->validate();
     } catch (FacebookRequestException $exception) {
         // Session not valid, Graph API returned an exception with the reason.
         throw new FacebookException($exception->getMessage());
     } catch (\Exception $exception) {
         // Graph API returned info, but it may mismatch the current app or have expired.
         throw new FacebookException($exception->getMessage());
     }
 }

 /**
  * Ask for a facebook session 
  * @return boolean
  */
 public final function hasLoggedIn()
 {
     if (is_null($this->fbsession) and !is_null($this->session)) {
         return $this->session->getData("_facebookSession") ?: false;
     }
     return $this->fbsession->validate();
 }

 /**
  * Try tlo initialize FacebookSession with a providedd acces token
  *
  * @param String $accessToken Tha external accessToken
  * @throws Exceptions\PhacebookException
  */
 private function tryValidateSession($accessToken)
 {
     $this->facebookSession = new FacebookSession($accessToken);
     try {
         $this->facebookSession->validate();
     } catch (FacebookSDKException $e) {
         throw new PhacebookException($e->getMessage());
     }
 }

 public function facebook()
 {
     $facebook_default_scope = explode(',', $this->ci->config->item("facebook_default_scope"));
     $facebook_app_id = $this->ci->config->item("facebook_app_id");
     $facebook_api_secret = $this->ci->config->item("facebook_api_secret");
     // init app with app id and secret
     FacebookSession::setDefaultApplication($facebook_app_id, $facebook_api_secret);
     // login helper with redirect_uri
     $helper = new FacebookRedirectLoginHelper(site_url('login/facebook'));
     // see if a existing session exists
     if (isset($_SESSION) && isset($_SESSION['fb_token'])) {
         // create new session from saved access_token
         $session = new FacebookSession($_SESSION['fb_token']);
         // validate the access_token to make sure it's still valid
         try {
             if (!$session->validate()) {
                 $session = null;
             }
         } catch (Exception $e) {
             // catch any exceptions
             $session = null;
         }
     }
     if (!isset($session) || $session === null) {
         // no session exists
         try {
             $session = $helper->getSessionFromRedirect();
         } catch (FacebookRequestException $ex) {
             // When Facebook returns an error
             // handle this better in production code
             print_r($ex);
         } catch (Exception $ex) {
             // When validation fails or other local issues
             // handle this better in production code
             print_r($ex);
         }
     }
     // see if we have a session
     if (isset($session)) {
         // save the session
         $_SESSION['fb_token'] = $session->getToken();
         // create a session using saved token or the new one we generated at login
         $session = new FacebookSession($session->getToken());
         // graph api request for user data
         //$request = new FacebookRequest($session, 'GET', '/me/friends');
         $request = new FacebookRequest($session, 'GET', '/me?fields=id,name,picture,friends');
         $response = $request->execute();
         // get response
         $graphObject = $response->getGraphObject()->asArray();
         $fb_data = array('me' => $graphObject, 'loginUrl' => $helper->getLoginUrl($facebook_default_scope));
         $this->ci->session->set_userdata('fb_data', $fb_data);
     } else {
         $fb_data = array('me' => null, 'loginUrl' => $helper->getLoginUrl($facebook_default_scope));
         $this->ci->session->set_userdata('fb_data', $fb_data);
     }
     return $fb_data;
 }

 public function isLoggedIn()
 {
     $logged = false;
     if (!empty($this->session)) {
         try {
             $this->session->validate();
             $logged = true;
         } catch (FacebookRequestException $ex) {
             // Session not valid, Graph API returned an exception with the reason.
             Log::warning($ex->getMessage());
         } catch (Exception $ex) {
             // Graph API returned info, but it may mismatch the current app or have expired.
             Log::warning($ex->getMessage());
         }
         return $logged;
     } else {
         return $logged;
     }
 }

 public function exchange_long_lived_token($access_token)
 {
     $session = new FacebookSession($access_token);
     // Check validate token
     if ($session->validate()) {
         $long_lived_session = $session->getLongLivedSession();
         return $long_lived_session->getToken();
     }
     return false;
 }

function isLogged()
{
    // Inicializações para autenticação
    // Crie um aplicativo no Facebook e configure aqui o ID e a chave secreta obtidos no site
    $id = '987654321012345';
    $secret = 'aeiou12345qwert98765asdfg1234567';
    FacebookSession::setDefaultApplication($id, $secret);
    // Inicializa sessão PHP
    session_start();
    // Se o cookie foi recebido numa requisição anterior, e o
    // token FB já foi recuperado, necessita apenas autenticar
    // o usuário no FB usando o token
    if (isset($_SESSION['token'])) {
        $session = new FacebookSession($_SESSION['token']);
        try {
            if (!$session->validate($id, $secret)) {
                unset($session);
            }
        } catch (FacebookRequestException $ex) {
            // Facebook retornou um erro
            // return [false, $ex->getMessage()];
            unset($session);
        } catch (\Exception $ex) {
            // return [false, $ex->getMessage()];
            unset($session);
        }
    }
    // Se o cookie ainda não foi recebido (primeira requisição
    // do cliente), recupera e grava na variável de sessão PHP.
    // Executa autenticação no FB
    if (!isset($session)) {
        try {
            $helper = new FacebookJavaScriptLoginHelper();
            $session = $helper->getSession();
            if ($session) {
                $_SESSION['token'] = $session->getToken();
            }
        } catch (FacebookRequestException $ex) {
            // Facebook retornou um erro
            unset($session);
            return [false, $ex->getMessage()];
        } catch (\Exception $ex) {
            // Falha na validação ou outro erro
            unset($session);
            return [false, $ex->getMessage()];
        }
    }
    // Facebook aceitou usuário/senha
    if (isset($session) && $session) {
        return [true, $_SESSION['token']];
    }
    // Facebook rejeitou usuário/senha
    return [false, "Usuário/senha inválida"];
}

 public function validate()
 {
     try {
         FacebookSession::setDefaultApplication($this->getParam('APP_ID'), $this->getParam('APP_SECRET'));
         $session = new FacebookSession($this->getParam('TOKEN'));
         $session->validate();
     } catch (FacebookSDKException $f) {
         return false;
     }
     return true;
 }

 /**
  * Get the FacebookSession through an access_token.
  *
  * @param  string $accessToken
  * @return FacebookSession
  */
 private function getFacebookSession($accessToken)
 {
     $facebookSession = new FacebookSession($accessToken);
     try {
         $facebookSession->validate();
         return $facebookSession;
     } catch (FacebookRequestException $ex) {
         throw new FacebookException($ex->getMessage());
     } catch (\Exception $ex) {
         throw new FacebookException($ex->getMessage());
     }
 }

 public function matchUser($access_token)
 {
     FacebookSession::setDefaultApplication('1594113490874544', 'fca50280932a6065e68a540ac3f2925b');
     $session = new FacebookSession($access_token);
     try {
         $session->validate();
     } catch (FacebookRequestException $ex) {
         return false;
     } catch (\Exception $ex) {
         return false;
     }
     return true;
 }

 /**
  * Initializes facebook's connection.
  *
  * @throws FacebookRequestException
  * @throws \Exception
  */
 private function initialize()
 {
     FacebookSession::enableAppSecretProof(false);
     $session = new FacebookSession($this->accessToken);
     try {
         $session->validate();
     } catch (FacebookRequestException $e) {
         $this->entry->addException($e->getMessage());
     } catch (\Exception $e) {
         $this->entry->addException($e->getMessage());
     }
     $this->session = $session;
 }

 /**
  * Get the FacebookSession through an access_token.
  *
  * @param string $accessToken
  * @return FacebookSession
  */
 public function getFacebookSession($accessToken)
 {
     $session = new FacebookSession($accessToken);
     // Validate the access_token to make sure it's still valid
     try {
         if (!$session->validate()) {
             $session = null;
         }
     } catch (\Exception $e) {
         // Catch any exceptions
         $session = null;
     }
     return $session;
 }

 public function loginAction($appId, Request $request)
 {
     $ret = array('success' => false);
     if ($request->request->get('facebook_token') != null && 'POST' === $request->getMethod()) {
         $em = $this->getDoctrine();
         $app = $em->getRepository('KeosuCoreBundle:App')->find($appId);
         $configPackages = $app->getConfigPackages();
         $fbAppId = $configPackages[KeosuGadgetFaceBookBundle::PLUGIN_NAME]['fbAppId'];
         $fbAppSecret = $configPackages[KeosuGadgetFaceBookBundle::PLUGIN_NAME]['fbAppSecret'];
         FacebookSession::setDefaultApplication($fbAppId, $fbAppSecret);
         $session = new FacebookSession($request->request->get('facebook_token'));
         try {
             $session->validate();
             $user_profile = (new FacebookRequest($session, 'GET', '/me'))->execute()->getGraphObject(GraphUser::className());
             // user Email
             $email = $user_profile->getProperty('email');
             $userManager = $this->container->get('fos_user.user_manager');
             $user = $userManager->findUserByUsernameOrEmail($email);
             // the user doesn't have account
             if ($user == null) {
                 $user = $userManager->createUser();
                 $user->setUsername($email);
                 $user->setEnabled(true);
                 $user->setPlainPassword(\md5($email . \rand()));
                 $user->setEmail($email);
                 $user->setAccountType('facebook');
                 $userManager->updateUser($user);
             }
             if ($user->getAccountType() == 'facebook') {
                 // We log the user
                 $token = new UsernamePasswordToken($user, null, 'main', $user->getRoles());
                 $this->get('security.context')->setToken($token);
                 $this->get('session')->set('_security_main', serialize($token));
                 $ret['success'] = true;
             } else {
                 $ret['message'] = "This email is allready used with an other account";
             }
         } catch (FacebookRequestException $ex) {
             echo $ex->getMessage();
         } catch (\Exception $ex) {
             echo $ex->getMessage();
         }
     } else {
         $ret['message'] = 'unable to login with facebook';
     }
     return new JsonResponse($ret);
 }

 /**
  * @param string $accessToken
  * @return bool
  */
 public function facebook($accessToken = null)
 {
     if (empty($accessToken)) {
         return false;
     }
     FacebookSession::setDefaultApplication(Config::get('verify::facebook.appId'), Config::get('verify::facebook.appSecret'));
     $session = new FacebookSession($accessToken);
     try {
         $session->validate(Config::get('verify::facebook.appId'), Config::get('verify::facebook.appSecret'));
         $data = $session->getSessionInfo()->asArray();
         return array('valid' => true, 'user_id' => $data['user_id'], 'app_id' => $data['app_id'], 'message' => 'Access Token is valid.');
     } catch (FacebookRequestException $ex) {
         return array('valid' => false, 'messages' => $ex->getMessage());
     } catch (Exception $ex) {
         return array('valid' => false, 'messages' => $ex->getMessage());
     }
 }

 private function getSession()
 {
     $token = get_option($this->tokenOptionsKey, "");
     $session = new FacebookSession($token);
     // To validate the session:
     try {
         $session->validate();
         return $session;
     } catch (FacebookRequestException $ex) {
         // Session not valid, Graph API returned an exception with the reason.
         echo $ex->getMessage();
         return null;
     } catch (\Exception $ex) {
         // Graph API returned info, but it may mismatch the current app or have expired.
         echo $ex->getMessage();
         return null;
     }
 }