/**
* @param UserResponseInterface $response
* @return User
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$username = $response->getUsername();
/** @var User $user */
$user = $this->userManager->findUserBy(['slackUserName' => $response->getUsername()]);
if ($user === null) {
$user = $this->userManager->createUser();
$user->setSlackUserName($username);
$user->setSlackAccessToken($response->getAccessToken());
$user->setUsername($response->getNickname());
$user->setEmail($response->getEmail());
$user->setRealName($response->getRealName());
$user->setPassword($username);
$user->setEnabled(true);
$this->userManager->updateUser($user);
$token = new Token($user);
$this->tokenRepository->persist($token);
$user->addToken($token);
$this->userManager->updateUser($user);
return $user;
}
$user = parent::loadUserByOAuthUserResponse($response);
$user->setSlackAccessToken($response->getAccessToken());
$user->setRealName($response->getRealName());
$token = new Token($user);
$this->tokenRepository->persist($token);
$user->addToken($token);
$this->userManager->updateUser($user);
return $user;
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$username = $response->getUsername();
$email = $response->getEmail();
$service = $response->getResourceOwner()->getName();
/** @var UserOauthAccount $connection */
$connection = $this->em->getRepository('OjsUserBundle:UserOauthAccount')->findOneBy(['providerId' => $username, 'provider' => $service]);
if (!$connection && !empty($email)) {
$userByEmail = $this->userManager->findUserByEmail($email);
if ($userByEmail) {
$connection = new UserOauthAccount();
$connection->setUser($userByEmail);
$connection->setProvider($service);
$connection->setProviderId($response->getUsername());
}
}
if (!$connection || $connection->getUser() === null) {
$message = sprintf("User not found. Please register first and then connect the account from your profile.", $username);
throw new AccountNotLinkedException($message);
}
$connection->setToken($response->getAccessToken());
$this->em->persist($connection);
$this->em->flush();
return $connection->getUser();
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$google_id = $response->getUsername();
$email = $response->getEmail();
$nickname = $response->getNickname();
$realname = $response->getRealName();
$avatar = $response->getProfilePicture();
$this->session->set('email', $email);
$this->session->set('nickname', $nickname);
$this->session->set('realname', $realname);
$this->session->set('avatar', $avatar);
$qb = $this->doctrine->getManager()->createQueryBuilder();
$qb->select('u')->from('BookBundle:User', 'u')->where('u.googleId = :gid')->setParameter('gid', $google_id)->setMaxResults(1);
$result = $qb->getQuery()->getResult();
if (!count($result)) {
$user = new User();
$user->setUsername($google_id);
$user->setRealname($realname);
$user->setNickname($nickname);
$user->setEmail($email);
$user->setGoogleId($google_id);
$user->setLocked(false);
$factory = $this->container->get('security.encoder_factory');
$encoder = $factory->getEncoder($user);
$password = $encoder->encodePassword(md5(uniqid(), $user->getSalt()));
$user->setPassword($password);
$em = $this->doctrine->getManager();
$em->persist($user);
$em->flush();
} else {
$user = $result[0];
}
$this->session->set('id', $user->getId());
return $this->loadUserByUsername($response->getUsername());
}
/**
* Create user from response
*
* @param UserResponseInterface $response
*
* @return User
*/
private function createUserFromResponse(UserResponseInterface $response)
{
/** @var User $user User */
$user = $this->userManager->createUser();
$user->setUsername($response->getUsername())->setFullName($response->getRealName())->setEmail($response->getEmail())->setEnabled(true)->setPlainPassword(uniqid())->setFacebookId($response->getUsername())->setFacebookAccessToken($response->getAccessToken());
$this->eventDispatcher->dispatch(AppEvents::FACEBOOK_USER_CONNECTED, new FacebookUserConnectedEvent($user));
$this->userManager->updateUser($user);
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}();
}
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response, $email = "")
{
$useremail = $response->getEmail();
if ($useremail == "") {
$useremail = $email;
}
if ($useremail != "") {
$username = $useremail;
} else {
$username = $response->getUsername();
}
/** @var User $user */
$user = $this->userManager->findUserByUsernameOrEmail($username);
$service = $response->getResourceOwner()->getName();
$setterID = $service . "Id";
$setter = 'set' . ucfirst($service);
$setter_id = $setter . 'Id';
$setter_token = $setter . 'AccessToken';
$getter = 'get' . ucfirst($service);
$getter_id = $getter . 'Id';
//when the user is registrating
if (null === $user) {
if ($this->userManager->findUserBy(array($setterID => $response->getUsername())) != null) {
$user = $this->userManager->findUserBy(array($setterID => $response->getUsername()));
return $user;
} else {
// create new user here
$user = $this->userManager->createUser();
$user->{$setter_id}($username);
$user->{$setter_token}($response->getAccessToken());
$user->setUsername($username);
$user->setFullname($response->getRealName());
if ($response->getResourceOwner()->getName() == 'facebook') {
$user->setPhoto('https://graph.facebook.com/' . $response->getUsername() . '/picture?type=large');
} else {
$user->setPhoto($response->getProfilePicture());
}
$user->setPassword($username);
$user->setEnabled(true);
if (filter_var($response->getEmail(), FILTER_VALIDATE_EMAIL)) {
$user->setEmail($response->getEmail());
$user->setConfirmationToken(null);
} else {
$user->setEmail($username);
}
$this->userManager->updateUser($user);
return $user;
}
} else {
$user->{$setter_id}($response->getUsername());
$user->{$setter_token}($response->getAccessToken());
$this->userManager->updateUser($user);
return $user;
}
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
//Data from Facebook response
$user_details = $response->getResponse();
$facebook_Id = $response->getUsername();
/* An ID like: 112259658235204980084 */
$email = $user_details['email'];
$first_name = $user_details['first_name'];
$last_name = $user_details['last_name'];
$nickname = $response->getNickname();
$realname = $response->getRealName();
$avatar = $response->getProfilePicture();
//set data in session
$this->session->set('email', $email);
$this->session->set('nickname', $nickname);
$this->session->set('realname', $realname);
$this->session->set('avatar', $avatar);
//Check if this Google user already exists in our app DB
$qb = $this->doctrine->getManager()->createQueryBuilder();
$qb->select('u')->from('CvProUserBundle:User', 'u')->where('u.facebookId = :gid')->setParameter('gid', $facebook_Id)->setMaxResults(1);
$result = $qb->getQuery()->getResult();
//add to database if doesn't exist
if (!count($result)) {
$user = new User();
$user->setUsername($facebook_Id);
$user->setFirstName($first_name);
$user->setLastName($last_name);
// $user->setRealname($realname);
// $user->setNickname($nickname);
$user->setEmail($email);
$user->setFacebookId($facebook_Id);
//$user->setRoles('ROLE_USER');
//Set some wild random pass since its irrelevant, this is facebook login
$factory = $this->container->get('security.encoder_factory');
$encoder = $factory->getEncoder($user);
$password = $encoder->encodePassword(md5(uniqid()), $user->getSalt());
$user->setPassword($password);
$em = $this->doctrine->getManager();
$em->persist($user);
$em->flush();
} else {
$user = $result[0];
/* return User */
}
//set id
$this->session->set('id', $user->getId());
return $this->loadUserByUsername($response->getUsername());
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$username = $response->getUsername();
$useremail = $response->getEmail();
// get facebook email id
$user = $this->userManager->findUserByEmail($useremail);
//$user = $this->userManager->findUserBy(array($this->getProperty($response) => $useremail));
//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());
$user->setUsername($useremail);
$user->setEmail($useremail);
$user->setPassword($username);
$user->setEnabled(true);
$this->userManager->updateUser($user);
return $user;
}
$user = $this->userManager->findUserByEmail($useremail);
$serviceName = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($serviceName) . 'AccessToken';
//update access token
$user->{$setter}($response->getAccessToken());
return $user;
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$generator = new SecureRandom();
$random = $generator->nextBytes(10);
$data = $response->getResponse();
$username = $response->getUsername();
$email = $response->getEmail() ? $response->getEmail() : $username;
$service = $response->getResourceOwner()->getName();
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $username));
//$user = $this->userManager->findUserBy(array($service.'Id' => $username));
//when the user is registrating
if (null === $user) {
$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($email);
$user->setEmail($email);
$user->setPlainPassword($random);
$user->setName($response->getRealName());
$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)
{
$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;
}
/**
* {@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->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;
}
/**
* {@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();
$user = $this->repository->findOneBy(array($this->getProperty($response) => $username));
// Register user
if (null === $user && $username) {
$service = $response->getResourceOwner()->getName();
$idField = $service . 'Id';
$tokenField = $service . 'AccessToken';
$class = $this->repository->getClassName();
$user = new $class();
$this->accessor->setValue($user, $idField, $username);
$this->accessor->setValue($user, $tokenField, $response->getAccessToken());
$user->setUsername($username);
$user->setEmail($username);
$user->setIsActive(true);
$this->em->persist($user);
$this->em->flush();
return $user;
} elseif (!$username) {
throw new \InvalidArgumentException('Username missing');
} else {
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;
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$user = $this->userRepository->findOneBy(['spotifyId' => $response->getUsername()]);
if (!$user instanceof SpotifyUser) {
$user = new SpotifyUser($response->getUsername());
}
$user->setSpotifyId($response->getUsername())->setDisplayName($response->getRealName())->setAccessToken($response->getAccessToken())->setAccessTokenExpires(time() + $response->getExpiresIn())->setRefreshToken($response->getRefreshToken())->setProfileUrl($response->getResponse()['href']);
$responseHasImages = isset($response->getResponse()['images']) && is_array($response->getResponse()['images']);
$responseImageExists = array_key_exists('url', $response->getResponse()['images'][0]);
if ($responseHasImages && $responseImageExists) {
$user->setImageUrl($response->getResponse()['images'][0]['url']);
}
$this->em->persist($user);
$this->em->flush();
return $this->loadUserByUsername($user->getUsername());
}
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)
{
if (!$this->cm->get('oro_sso.enable_google_sso')) {
throw new \Exception('SSO is not enabled');
}
$username = $response->getUsername();
if ($username === null) {
throw new BadCredentialsException('Bad credentials');
}
if (!$this->isEmailEnabledForOauth($response->getEmail())) {
throw new EmailDomainNotAllowedException('Bad credentials');
}
$user = $this->userManager->findUserBy([$this->getOAuthProperty($response) => $username]);
if (!$user) {
$user = $this->userManager->findUserByEmail($response->getEmail());
if ($user) {
$user->setGoogleId($username);
$this->userManager->updateUser($user);
}
}
if (!$user || !$user->isEnabled()) {
throw new BadCredentialsException('Bad credentials');
}
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;
}
}
/**
* {@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;
}
/**
* {@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)
{
$name = $response->getRealName();
$email = $response->getEmail();
$clientId = $response->getUsername();
$token = $response->getAccessToken();
$user = $this->doctrine->getRepository('UserUserBundle:Users')->findOneByOAuthUser($clientId);
/** @var Users $user */
if (!$user) {
$service = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($service);
$setterId = $setter . "Id";
$setterToken = $setter . 'AccessToken';
$user = new Users();
$user->setRealname($name);
$user->setUsername($email);
$user->{$setterId}($clientId);
$user->{$setterToken}($token);
$user->setPassword(sha1($clientId));
$roles = $this->doctrine->getRepository('UserUserBundle:Roles')->findOneBy(['role' => 'ROLE_USER']);
$user->addRole($roles);
$this->doctrine->getManager()->persist($user);
$this->doctrine->getManager()->flush();
$userId = $user->getId();
} else {
$userId = $user->getId();
}
if (!$userId) {
throw new UsernameNotFoundException('Возникла проблема добавления или определения пользователя');
}
return $this->loadUserByUsername($userId);
}
/**
* {@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;
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$resourceOwner = $response->getResourceOwner();
if (!$resourceOwner instanceof FacebookResourceOwner) {
throw new UnsupportedUserException('Only Facebook users are supported');
}
return $this->loadUserByData(['userId' => $response->getUsername(), 'service' => 'facebook', 'username' => $response->getNickname(), 'realname' => $response->getRealName(), 'email' => $response->getEmail(), 'picture' => $response->getProfilePicture()]);
}
/**
* Create user from response
*
* @param UserResponseInterface $response
*
* @return User
*/
private function createUserFromResponse(UserResponseInterface $response)
{
$email = $response->getEmail() ?: $response->getUsername() . '@example.com';
/** @var User $user */
$user = $this->userManager->createUser();
$user->setEmail($email);
$user->setUsername($response->getNickname());
$user->setEnabled(true);
$user->setPlainPassword(uniqid());
$user->setGithubId($response->getUsername());
// Move to separate listener
if (in_array($response->getUsername(), $this->adminGitHubIds)) {
$user->addRole('ROLE_ADMIN');
}
$this->userManager->updateUser($user);
return $user;
}
/**
* @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;
}
private function loginUserGoogle(UserResponseInterface $response)
{
$username = $response->getUsername();
$firstName = $response->getResponse()['given_name'];
$lastName = $response->getResponse()['family_name'];
$gender = $response->getResponse()['gender'];
$email = $response->getEmail();
return ['loginField' => 'googleLogin', 'username' => $username, 'firstName' => $firstName, 'lastName' => $lastName, 'gender' => $gender, 'email' => $email];
}
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)
{
$username = $response->getUsername();
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $username));
if (null === $user || null === $username) {
throw new AccountNotLinkedException(sprintf("User '%s' not found.", $username));
}
return $user;
}
