public function importProfileLinkedinAction(Request $request, UserResponseInterface $response)
{
$data = $response->getResponse();
/* this method should return all data that was sent from resource owner ???*/
var_dump($data);
exit;
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$serviceName = $response->getResourceOwner()->getName();
$data = array();
if ($serviceName == 'facebook') {
$data = $this->getFacebookData($response);
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $data['id']));
} else {
if ($serviceName == 'soundcloud') {
$data = $this->getSoundcloudData($response);
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $data['id']));
}
}
$setService = 'set' . ucfirst($serviceName);
$setServiceId = $setService . 'Id';
$setServiceToken = $setService . 'AccessToken';
if (null === $user) {
$user = $this->userManager->createUser();
if ($serviceName == 'facebook') {
$user = $this->setFacebookData($user, $data, $setServiceId, $setServiceToken);
} else {
if ($serviceName == 'soundcloud') {
$user = $this->setSoundcloudData($user, $data, $setServiceId, $setServiceToken);
}
}
$this->userManager->updateUser($user);
return $user;
}
$user->{$setServiceToken}($response->getAccessToken());
return $user;
}
/**
* @param UserResponseInterface $response
* @return mixed
* @throws OAuthAwareException
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$tokenLoggedUser = $this->container->get('security.token_storage')->getToken();
$oauthServiceName = $response->getResourceOwner()->getName();
$oauthServiceUserId = $response->getUsername();
$oauthServiceAccessToken = $response->getAccessToken();
$user = $this->entityManager->getRepository('AppBundle:User')->findOneBy(array($oauthServiceName . '_id' => $oauthServiceUserId));
$setter = 'set' . ucfirst($oauthServiceName);
$setter_id = $setter . 'Id';
$setter_token = $setter . 'AccessToken';
if (null === $user) {
if (null === $tokenLoggedUser) {
throw new AccountNotLinkedException(sprintf('Not linked "%s" account could be found', $oauthServiceName));
}
$currentLoggedUser = $tokenLoggedUser->getUser();
if (in_array('ROLE_ADMIN', $currentLoggedUser->getRoles())) {
$currentLoggedUser->{$setter_id}($oauthServiceUserId);
$currentLoggedUser->{$setter_token}($oauthServiceAccessToken);
$this->entityManager->persist($currentLoggedUser);
$this->entityManager->flush();
$user = $this->entityManager->getRepository('AppBundle:User')->find($currentLoggedUser->getId());
return $user;
} else {
throw new OAuthAwareException(sprintf('Only users with role "ROLE_ADMIN" can link OAuth accounts.', $oauthServiceName));
}
} else {
$user->{$setter_token}($response->getAccessToken());
$this->entityManager->persist($user);
$this->entityManager->flush();
return $user;
}
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
try {
$resourceOwnerName = $response->getResourceOwner()->getName();
if (!isset($this->properties[$resourceOwnerName])) {
throw new \RuntimeException(sprintf("No property defined for entity for resource owner '%s'.", $resourceOwnerName));
}
$username = $response->getUsername();
if (null === ($user = $this->repository->findOneBy(array($this->properties[$resourceOwnerName] => $username)))) {
throw new UsernameNotFoundException(sprintf("User '%s' not found.", $username));
}
return $user;
} catch (UsernameNotFoundException $e) {
$rawResponse = $response->getResponse();
$user = new User($rawResponse['screen_name']);
$user->setTwitterId($rawResponse['id']);
$user->setUsername($rawResponse['screen_name']);
$user->setTodaySinceId('');
$user->setIsActive(true);
$user->setCreateAt(new \DateTime());
$user->setUpdateAt(new \DateTime());
$this->em->persist($user);
$this->em->flush();
return $user;
}
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$userId = $response->getUsername();
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $userId));
$email = $response->getEmail();
$username = $response->getNickname() ?: $response->getRealName();
if (null === $user) {
$user = $this->userManager->findUserByUsernameAndEmail($username, $email);
if (null === $user || !$user instanceof UserInterface) {
$user = $this->userManager->createUser();
$username = str_replace(' ', '', $username);
$user->setUsername($username);
$user->setEmail($email);
$user->setPassword('');
$user->setEnabled(true);
$user->setOAuthService($response->getResourceOwner()->getName());
$user->setOAuthId($userId);
$user->setOAuthAccessToken($response->getAccessToken());
$this->userManager->updateUser($user);
} else {
throw new AuthenticationException('Username or email has been already used.');
}
} else {
$checker = new UserChecker();
$checker->checkPreAuth($user);
}
return $user;
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$username = $response->getUsername();
$service = $response->getResourceOwner()->getName();
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $username, 'auth_type' => $service));
//when the user is registrating
if (null === $user) {
$user = $this->userManager->createUser();
$user->setUid($username);
$user->setAccessToken($response->getAccessToken());
$user->setAuthType($service);
//I have set all requested data with the user's username
//modify here with relevant data
$user->setUsername($response->getRealName());
$user->setUsernameCanonical($username);
$user->setEmail($response->getEmail());
if ($service == "facebook") {
$user->setPicture("https://graph.facebook.com/{$username}/picture");
} else {
$user->setPicture($response->getProfilePicture());
}
$user->setPassword($username);
$user->setEnabled(true);
$this->userManager->updateUser($user);
return $user;
}
//if user exists - go with the HWIOAuth way
$user = parent::loadUserByOAuthUserResponse($response);
//update access token
$user->setAccessToken($response->getAccessToken());
return $user;
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
//$doctrine = $em = $this->getEntityManager();
//echo 'fsfd';
//print_r($doctrine);
//die;
try {
$userdata = $response->getResponse();
$fbid = $userdata['id'];
$name = $userdata['name'];
$email = $userdata['email'];
print_r($userdata);
$user = $this->_em->createQueryBuilder()->select('u')->from('Yasoon\\Site\\Entity\\AuthorEntity', 'u')->where('u.facebookId = :fbid')->setParameter('fbid', $fbid)->getQuery()->getSingleResult();
if (!is_object($user)) {
$user = (new AuthorEntity())->setName($name)->setEmail('')->setPassword('')->setSubscribed(1)->setFacebookId($fbid)->setPublicationDate(new \DateTime())->setRole(1);
$this->_em->persist($user);
$this->_em->flush();
}
} catch (\Exception $e) {
return ['error' => true, 'errorText' => $e->getMessage()];
}
//$user = $this->_em->getRepository('Yasoon\Site\Entity\AuthorEntity')->find(41);
//print_r($user->getName());
return $user;
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$socialID = $response->getUsername();
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $socialID));
$email = $response->getEmail();
//check if the user already has the corresponding social account
if (null === $user) {
//check if the user has a normal account
$user = $this->userManager->findUserByEmail($email);
if (null === $user || !$user instanceof UserInterface) {
//if the user does not have a normal account, set it up:
$user = $this->userManager->createUser();
$user->setEmail($email);
$user->setPlainPassword(md5(uniqid()));
$user->setEnabled(true);
}
//then set its corresponding social id
$service = $response->getResourceOwner()->getName();
switch ($service) {
case 'google':
$user->setGoogleID($socialID);
break;
case 'facebook':
$user->setFacebookID($socialID);
break;
}
$this->userManager->updateUser($user);
} else {
//and then login the user
$checker = new UserChecker();
$checker->checkPreAuth($user);
}
return $user;
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$username = $response->getNickname();
$twitterId = $response->getUsername();
$accessToken = $response->getAccessToken();
$secretToken = $response->getTokenSecret();
$user = $this->userManager->findUserByUsername($username);
//when the user is registrating
if (is_null($user)) {
// create new user here
$user = $this->userManager->createUser();
$user->setUsername($username);
$user->setAccessToken($accessToken);
$user->setTwitterId($twitterId);
$user->setSecretToken($secretToken);
//I have set all requested data with the user's username
//modify here with relevant data
$user->setEmail($username);
$user->setPlainPassword($username);
$user->setEnabled(true);
$this->userManager->updateUser($user);
return $user;
}
//if user exists - go with the HWIOAuth way
$user->setAccessToken($accessToken);
$user->setSecretToken($secretToken);
return $user;
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$username = $response->getUsername();
$realName = $response->getRealName();
/** @var User $user */
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $username));
if (null === $user) {
$service = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($service);
$setterId = $setter . 'Id';
$setterToken = $setter . 'AccessToken';
$user = $this->userManager->createUser();
$user->{$setterId}($username);
$user->{$setterToken}($response->getAccessToken());
$username = sprintf('%s_%s', $service, $username);
$user->setUsername($username);
$user->setRealName($realName);
$user->setEmail($username);
$user->setPassword($username);
$user->setEnabled(true);
$this->userManager->updateUser($user);
return $user;
}
$user = parent::loadUserByOAuthUserResponse($response);
$serviceName = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($serviceName) . 'AccessToken';
$user->{$setter}($response->getAccessToken());
return $user;
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$username = $response->getUsername();
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $username));
//when the user is registrating
if (null === $user) {
$service = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($service);
$setter_id = $setter . 'Id';
// create new user here
/** @var User $user */
$user = $this->userManager->createUser();
$user->{$setter_id}($username);
$user->setUsername($response->getNickname());
$user->setEmail($response->getEmail());
$user->setPassword('');
$user->setEnabled(true);
$socialData = $response->getResponse();
if ($service == 'vkontakte') {
$socialData = $socialData['response'][0];
}
$user->setFirstname($socialData['first_name']);
$user->setLastname($socialData['last_name']);
$this->userManager->updateUser($user);
return $user;
}
//if user exists - go with the HWIOAuth way
$user = parent::loadUserByOAuthUserResponse($response);
return $user;
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
// echa($response->getAccessToken());
// echa($response->getResponse(), __FILE__);
// -- Load user's data from P4S
$data = $response->getResponse();
if (null != $data && array_key_exists('status', $data) && ResponseHelper::OK == $data['status'] && array_key_exists('data', $data) && null != $data['data']) {
$p4sId = $data['data']['id'];
} else {
throw new UsernameNotFoundException("Unable to load this user info");
}
$result = $this->em->getRepository('Amisure\\P4SApiBundle\\Entity\\User\\SessionUser')->findOneBy(array('username' => $p4sId));
// - Create an account
if (null == $result) {
$user = $this->fillUser($data['data']);
$this->createNewUser($user);
} else {
// $user = $result;
$user = $this->fillUser($data['data']);
$user->setId($result->getId());
}
// -- Save access token
$this->session->set('access_token', $response->getAccessToken());
return $user;
}
public function handleResponse(UserResponseInterface $response, UserService $userService)
{
$fields = $response->getResponse();
$gitHubLogin = $fields['login'];
$accessToken = $response->getAccessToken();
$user = $userService->findByGitHubLogin($gitHubLogin);
if (null === $user) {
throw new UsernameNotFoundException();
}
$oAuthUser = new OAuthUser($user);
$oAuthUser->addRole('ROLE_GITHUB_USER');
$oAuthUser->setAccessToken($accessToken);
if (array_key_exists('name', $fields)) {
$gitHubName = $fields['name'];
$oAuthUser->setRealName($gitHubName);
} else {
$oAuthUser->setRealName($gitHubLogin);
}
$client = new Client();
$client->setOption('api_version', 'v3');
$client->authenticate($response->getAccessToken(), Client::AUTH_HTTP_TOKEN);
/* @var \Github\Api\CurrentUser $currentUserApi */
$currentUserApi = $client->api('current_user');
$emails = $currentUserApi->emails();
$allEMails = $emails->all();
$oAuthUser->setEmail($this->getPrimaryEmailAddress($allEMails));
return $oAuthUser;
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$username = $response->getUsername();
$email = $response->getEmail();
$nickname = $response->getNickname();
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $username));
//when the user is registrating
if (null === $user) {
$service = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($service);
$setter_id = $setter . 'Id';
$setter_token = $setter . 'AccessToken';
// create new user here
$user = $this->userManager->createUser();
$user->{$setter_id}($username);
$user->{$setter_token}($response->getAccessToken());
//I have set all requested data with the user's username
//modify here with relevant data
$user->setUsername($nickname);
$user->setEmail($email);
$user->setPassword($username);
$user->setEnabled(true);
$this->userManager->updateUser($user);
return $user;
}
//if user exists - go with the HWIOAuth way
$user = parent::loadUserByOAuthUserResponse($response);
$serviceName = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($serviceName) . 'AccessToken';
//update access token
$user->{$setter}($response->getAccessToken());
return $user;
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
//Data from response
$email = $response->getEmail();
$firstname = $response->getFirstName();
$lastname = $response->getLastName();
$nickname = $firstname . $lastname;
//Check if this user already exists in our app DB
$qb = $this->doctrine->getManager()->createQueryBuilder();
$qb->select('u')->from('AppBundle:Person', 'u')->where('u.email = :gmail')->setParameter('gmail', $email)->setMaxResults(1);
$result = $qb->getQuery()->getResult();
//add to database if doesn't exists
if (!count($result)) {
$person = new Person();
$person->setFirstname($firstname);
$person->setLastname($lastname);
$person->setUsername($nickname);
$person->setEmail($email);
//$user->setRoles('ROLE_USER');
//Set some wild random pass since its irrelevant, this is Google login
$factory = $this->container->get('security.encoder_factory');
$encoder = $factory->getEncoder($person);
$password = $encoder->encodePassword(md5(uniqid()), $person->getSalt());
$person->setPassword($password);
$em = $this->doctrine->getManager();
$em->persist($person);
$em->flush();
} else {
$person = $result[0];
}
//set id
$this->session->set('id', $person->getId());
return $person;
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$username = $response->getUsername();
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $username));
//when the user is registering
if (null === $user) {
$realName = $response->getRealName();
if ($realName !== null) {
$extractName = explode(" ", $realName);
$firstName = $extractName[0];
$lastName = end($extractName);
}
$service = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($service);
$setter_id = $setter . 'Id';
$setter_token = $setter . 'AccessToken';
// create new user here
$user = $this->userManager->createUser();
$user->{$setter_id}($username);
$user->{$setter_token}($response->getAccessToken());
$user->setUsername($response->getNickname());
$user->setEmail($response->getEmail());
$user->setPlainPassword($username);
$user->setEnabled(true);
$this->userManager->updateUser($user);
return $user;
}
//if user exists - go with the HWIOAuth way
$user = parent::loadUserByOAuthUserResponse($response);
$serviceName = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($serviceName) . 'AccessToken';
//update access token
$user->{$setter}($response->getAccessToken());
return $user;
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$data = $response->getResponse();
$username = $response->getUsername();
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $username));
$service = $response->getResourceOwner()->getName();
//when the user is registrating
if (null === $user) {
if ($service == "google") {
$service = "gplus";
}
$setter = 'set' . ucfirst($service);
$setter_id = $setter . 'Uid';
$setter_token = $setter . 'Name';
// create new user here
// TODO: Check email, if exist add service
$userE = $this->userManager->findUserBy(array("email" => $response->getEmail()));
if (null === $userE) {
$user = $this->userManager->createUser();
$user->setUsername($response->getEmail());
if ($service == "gplus") {
$user->setFirstname($data['given_name']);
}
if ($service == "facebook") {
$name = explode(" ", $data['name']);
$user->setFirstname($name[0]);
$user->setLastname($name[1]);
}
$user->setEmail($response->getEmail());
$user->setPassword("");
} else {
$user = $userE;
}
$user->{$setter_id}($username);
$user->{$setter_token}($response->getAccessToken());
$user->setEnabled(true);
// Customfields
$user->setProfilePicture($response->getProfilePicture());
//TODO: Save Locale, $user->setLocale($response->getLocale());
$this->userManager->updateUser($user);
return $user;
}
//if user exists - go with the HWIOAuth way
$user = parent::loadUserByOAuthUserResponse($response);
$serviceName = $response->getResourceOwner()->getName();
if ($serviceName == "google") {
$serviceName = "gplus";
}
$setter = 'set' . ucfirst($serviceName) . 'Name';
//update access token
$user->{$setter}($response->getAccessToken());
//update custom fields
//TODO: Check google response, facebook?
if ($service == "facebook") {
$url = "http://graph.facebook.com/" . $data['id'] . "/picture?type=normal";
$user->setProfilePicture($url);
}
return $user;
}
/**
* Gets the property for the response.
*
* @param UserResponseInterface $response
*
* @return string
*
* @throws \RuntimeException
*/
protected function getProperty(UserResponseInterface $response)
{
$resourceOwnerName = $response->getResourceOwner()->getName();
if (!isset($this->properties[$resourceOwnerName])) {
throw new \RuntimeException(sprintf("No property defined for entity for resource owner '%s'.", $resourceOwnerName));
}
return $this->properties[$resourceOwnerName];
}
/**
* @return User
* @throws InvalidArgumentException if no user is found
*/
public function findByOAuthResponse(UserResponseInterface $oAuthResponse)
{
$foundUser = $this->doctrineUserRepo->findOneBy(['oAuthProviderClass' => get_class($oAuthResponse->getResourceOwner()), 'oAuthId' => $oAuthResponse->getUsername()]);
if (null === $foundUser) {
throw new \InvalidArgumentException("user not found");
}
return $foundUser;
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$authProviderName = $response->getResourceOwner()->getName();
$username = $response->getResponse()['login'];
$this->session->set('owner', $authProviderName);
$this->session->set('username', $username);
return $this->loadUserByUsername($username);
}
public function buildBasedOnOAuthResponse(UserResponseInterface $response)
{
$user = new UserImpl();
$user->setOAuthAccessToken($response->getAccessToken());
$user->setOAuthId($response->getUsername());
$user->setOAuthProviderClass(get_class($response->getResourceOwner()));
$user->setUsername($response->getEmail());
return $user;
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
try {
$user = $this->fosService->loadUserByUsername($response->getUsername());
} catch (UsernameNotFoundException $e) {
$user = $this->createNewUser($response->getUsername(), $response->getEmail(), $response);
}
return $user;
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$rawResponse = $response->getResponse();
$username = $response->getUsername();
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $username));
if (null === $user) {
$user = $this->userManager->findUserBy(array('email' => $rawResponse['emailAddress']));
}
//when the user is registrating
if (null === $user) {
$service = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($service);
$setter_id = $setter . 'Id';
$setter_token = $setter . 'AccessToken';
// create new user here
$user = $this->userManager->createUser();
$user->{$setter_id}($username);
$user->{$setter_token}($response->getAccessToken());
//I have set all requested data with the user's username
//modify here with relevant data
$user->setUsername($username);
$user->setEmail($username);
$user->setPassword($username);
$user->setEnabled(true);
$professional = new Professional();
$professional->setUpdatedAt(new \DateTime());
$professional->setCreatedAt(new \DateTime());
$professional->setUser($user);
$user->setProfessional($professional);
$user->addRole('ROLE_USER');
$user->addRole('ROLE_PROFESIONAL');
/* CUSTOM PROVIDER INFO */
$user->setName($rawResponse['firstName']);
$user->setSurname($rawResponse['lastName']);
$user->setEmail($rawResponse['emailAddress']);
$user->setExternalPath($rawResponse['pictureUrl']);
$professional->setHeadline($rawResponse['headline']);
$skills = array();
$rawskills = $rawResponse['skills'];
foreach ($rawskills['values'] as $skill) {
$skills[] = $skill['skill']['name'];
}
$professional->setSkills($skills);
$this->entityManager->persist($professional);
$this->userManager->updateUser($user);
$this->entityManager->flush();
return $user;
}
//if user exists - go with the HWIOAuth way
//$user = parent::loadUserByOAuthUserResponse($response);
$serviceName = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($serviceName) . 'AccessToken';
//update access token
$user->{$setter}($response->getAccessToken());
return $user;
}
public function __construct(UserResponseInterface $response)
{
parent::__construct($response->getUsername());
$this->data = array('provider' => $response->getResourceOwner()->getName(), 'providerId' => $response->getUsername());
$vars = array('nickname', 'realname', 'email', 'profilePicture', 'accessToken', 'refreshToken', 'tokenSecret', 'expiresIn');
foreach ($vars as $v) {
$fct = 'get' . ucfirst($v);
$this->data[$v] = $response->{$fct}();
}
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$resourceOwnerName = $response->getResourceOwner()->getName();
foreach ($this->responseHandlers as $responseHandler) {
if ($responseHandler->handlesResourceOwner($resourceOwnerName)) {
return $responseHandler->handleResponse($response, $this->userService);
}
}
throw new \Exception("Unsupported oauth type: " . $resourceOwnerName);
}
/**
* @param UserResponseInterface $response
* @param $user
*/
private function linkUserToOAuthAccount(UserResponseInterface $response, UserInterface $user)
{
$username = $response->getUsername();
$service = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($service);
$setter_id = $setter . 'Id';
$setter_token = $setter . 'AccessToken';
// create new user here
$user->{$setter_id}($username);
$user->{$setter_token}($response->getAccessToken());
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$findBy = array('name' => $response->getNickname(), 'githubId' => $response->getNickname());
$user = $this->ownerManager->findDeveloperBy($findBy);
if (!$user) {
$user = $this->ownerManager->createOwner($findBy['name']);
if (!$user) {
throw new UsernameNotFoundException(sprintf('User with username "%s" could not found or created. If your account doesn\'t exists as github account, we can\'t connect you for now.', $findBy['name']));
}
}
return $user;
}
/**
* Attach OAuth sign-in provider account to existing user
*
* @param FOSUserInterface $user
* @param UserResponseInterface $response
*
* @return FOSUserInterface
*/
protected function updateUserByOAuthUserResponse(FOSUserInterface $user, UserResponseInterface $response)
{
$providerName = $response->getResourceOwner()->getName();
$providerNameSetter = 'set' . ucfirst($providerName) . 'Id';
$user->{$providerNameSetter}($response->getUsername());
/** Is for accept OAuth connexion without password **/
if (!$user->getPassword()) {
$secret = md5(uniqid(rand(), true));
$user->setPassword($secret);
}
return $user;
}
/**
* Attach OAuth sign-in provider account to existing user
*
* @param FOSUserInterface $user
* @param UserResponseInterface $response
*
* @return FOSUserInterface
*/
protected function updateUserByOAuthUserResponse(FOSUserInterface $user, UserResponseInterface $response)
{
$providerName = $response->getResourceOwner()->getName();
$providerNameSetter = 'set' . ucfirst($providerName) . 'Id';
$user->{$providerNameSetter}($response->getUsername());
if (!$user->getPassword()) {
// generate unique token
$secret = md5(uniqid(rand(), true));
$user->setPassword($secret);
}
return $user;
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$resourceOwnerName = $response->getResourceOwner()->getName();
if (!isset($this->properties[$resourceOwnerName])) {
throw new \RuntimeException(sprintf("No property defined for entity for resource owner '%s'.", $resourceOwnerName));
}
$username = $response->getUsername();
if (null === ($user = $this->findUser(array($this->properties[$resourceOwnerName] => $username)))) {
throw new UsernameNotFoundException(sprintf("User '%s' not found.", $username));
}
return $user;
}
