/**
* @param UserResponseInterface|ResourceResponse $response
*
* @return UserInterface
*/
protected function createUserByOAuthUserResponse(UserResponseInterface $response)
{
/** @var DoSUserInterface $user */
$user = $this->userFactory->createNew();
/** @var CustomerInterface $customer */
$customer = $this->customerFactory->createNew();
// set default values taken from OAuth sign-in provider account
// todo: check security configuration provide by `fos....username_email`
if (null === $response->getEmail()) {
throw new AccountNoEmailException();
}
// set default values taken from OAuth sign-in provider account
if (null !== ($email = $response->getEmail())) {
$customer->setEmail($email);
}
if (!$user->getUsername()) {
$user->setUsername($response->getEmail() ?: $response->getNickname());
}
// set random password to prevent issue with not nullable field & potential security hole
$user->setPlainPassword(substr(sha1($response->getAccessToken()), 0, 10));
$user->setDisplayName($response->getNickname());
$user->setLocale($response->getLocale());
$user->setCustomer($customer);
$user->confirmed();
$customer->setFirstName($response->getFirstName());
$customer->setLastName($response->getLastName());
$customer->setGender($response->getGender() ?: CustomerInterface::UNKNOWN_GENDER);
$customer->setBirthday($response->getBirthday());
return $this->updateUserByOAuthUserResponse($user, $response);
}
/**
* {@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;
}
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());
}
/**
* {@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;
}
/**
* @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;
}
/**
* {@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)
{
$content = $response->getResponse();
$resourceOwner = $response->getResourceOwner();
try {
$user = $this->loadUserByServiceAndId($resourceOwner->getName(), $content['id']);
return $user;
} catch (\Exception $e) {
$name = $response->getRealName();
$nameArray = explode(' ', $name, 2);
$firstName = $response->getFirstName();
$lastName = $response->getLastName();
if (empty($firstName) || empty($lastName)) {
if (array_key_exists(0, $nameArray)) {
$firstName = ucfirst(strtolower($nameArray[0]));
}
if (array_key_exists(1, $nameArray)) {
$lastName = ucfirst(strtolower($nameArray[1]));
}
}
$user = array();
$user['firstName'] = $firstName;
$user['lastName'] = $lastName;
$user['username'] = $this->createUsername($response->getNickname());
$user['mail'] = $response->getEmail();
$this->session->set('icap.oauth.user', $user);
$resourceOwnerArray = array('name' => $resourceOwner->getName(), 'id' => $content['id']);
$this->session->set('icap.oauth.resource_owner', $resourceOwnerArray);
throw $e;
}
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
//data from facebook response
// dump($response->getAccessToken(), $response->getRefreshToken());
// die();
$id = $response->getUsername();
$nickname = $response->getNickname();
$email = $response->getEmail();
//set data in session
$this->session->set('id', $id);
$this->session->set('email', $email);
$this->session->set('access_token', $response->getAccessToken());
$this->session->set('refresh_token', $response->getRefreshToken());
/*
//get user by fid
$qb = $this->doctrine->getManager()->createQueryBuilder();
$qb ->select('u.id')
->from('AcmeDemoBundle:User', 'u')
->where('u.fid = :fid')
->setParameter('fid', $facebook_id)
->setMaxResults(1);
$result = $qb->getQuery()->getResult();
//add to database if doesn't exists
if ( !count($result) ) {
$User = new User();
$User->setCreatedAt(new \DateTime());
$User->setNickname($nickname);
$User->setRealname($realname);
$User->setEmail($email);
$User->setAvatar($avatar);
$User->setFID($facebook_id);
$em = $this->doctrine->getManager();
$em->persist($User);
$id = $em->flush();
} else {
$id = $result[0]['id'];
}
*/
//@TODO: hmm : is admin
if ($this->isUserAdmin($nickname)) {
$this->session->set('is_admin', true);
}
//parent:: returned value
return $this->loadUserByUsername($response->getNickname());
}
/**
* {@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()]);
}
private function loginUserFaceBook(UserResponseInterface $response)
{
$username = $response->getNickname();
$firstName = $response->getResponse()['first_name'];
$lastName = $response->getResponse()['last_name'];
$gender = $response->getResponse()['gender'];
$email = $response->getEmail();
return ['loginField' => 'fbLogin', 'username' => $username, 'firstName' => $firstName, 'lastName' => $lastName, 'gender' => $gender, 'email' => $email];
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
//Data from Google response
$social_id = $response->getUsername(); /* An ID like: 112259658235204980084 */
$email = $response->getEmail();
$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('BloggerBlogBundle:User', 'u')
->where('u.socialId = :sid')
->setParameter('sid', $social_id)
->setMaxResults(1);
$result = $qb->getQuery()->getResult();
//add to database if doesn't exists
if (!count($result)) {
$user = new User();
$user->setUsername($social_id);
$user->setRealname($realname);
$user->setNickname($nickname);
$user->setEmail($email);
$user->setSocialId($social_id);
//$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($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());
}
/**
* Set user information from form
*
* @param UserInterface $user
* @param UserResponseInterface $userInformation
*
* @return UserInterface
*/
protected function setUserInformation(UserInterface $user, UserResponseInterface $userInformation)
{
$user->setUsername($this->getUniqueUsername($userInformation->getNickname()));
foreach ($userInformation->getPaths() as $field => $map) {
$func = $this->camelize($field);
$setter = 'set' . $func;
$getter = 'get' . $func;
if (method_exists($user, $setter)) {
$user->{$setter}($userInformation->{$getter}());
}
}
return $user;
}
/**
* Ad-hoc creation of user
*
* @param UserResponseInterface $response
*
* @return SyliusUserInterface
*/
protected function createUserByOAuthUserResponse(UserResponseInterface $response)
{
$user = $this->userManager->createUser();
// set default values taken from OAuth sign-in provider account
if (null !== ($email = $response->getEmail())) {
$user->setEmail($email);
}
if (!$user->getUsername()) {
$user->setUsername($response->getEmail() ?: $response->getNickname());
}
// set random password to prevent issue with not nullable field & potential security hole
$user->setPlainPassword(substr(sha1($response->getAccessToken()), 0, 10));
$user->setEnabled(true);
return $this->updateUserByOAuthUserResponse($user, $response);
}
/**
* {@inheritDoc}
*/
public function process(Request $request, Form $form, UserResponseInterface $userInformation)
{
$formHandler = $this->reconstructFormHandler($request, $form);
// make FOSUB process the form already
$processed = $formHandler->process();
// if the form is not posted we'll try to set some properties
if ('POST' !== $request->getMethod()) {
$user = $form->getData();
$user->setUsername($this->getUniqueUsername($userInformation->getNickname()));
if ($userInformation instanceof AdvancedUserResponseInterface && method_exists($user, 'setEmail')) {
$user->setEmail($userInformation->getEmail());
}
$form->setData($user);
}
return $processed;
}
/**
* 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;
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$providerId = $this->getProviderIdFromName($response->getResourceOwner()->getName());
$identifier = $response->getUsername();
$username = $providerId . '-' . $identifier;
$user = $this->userMapper->fetchUserByUsername($username);
if (!$user) {
$oauth = $this->getUserOauthNew($providerId);
$oauth->setIdentifier($identifier);
$oauth->setNickname($response->getNickname());
$user = $this->getUserNew();
$user->setUsername($username);
$user->setOauthOnly(1);
$user->addOauth($oauth);
$this->userMapper->save($user);
}
return $user;
}
/**
* {@inheritDoc}
*/
public function process(Request $request, Form $form, UserResponseInterface $userInformation)
{
$user = $this->userManager->createUser();
// Try to get some properties for the initial form when coming from github
if ('GET' === $request->getMethod()) {
$user->setUsername($this->getUniqueUsername($userInformation->getNickname()));
$user->setEmail($userInformation->getEmail());
}
$form->setData($user);
if ('POST' === $request->getMethod()) {
$form->handleRequest($request);
if ($form->isValid()) {
$randomPassword = $this->tokenGenerator->generateToken();
$user->setPlainPassword($randomPassword);
$user->setEnabled(true);
$apiToken = substr($this->tokenGenerator->generateToken(), 0, 20);
$user->setApiToken($apiToken);
return true;
}
}
return false;
}
function it_should_create_new_user_when_none_was_found($userManager, $oauthRepository, UserInterface $user, UserResponseInterface $response, ResourceOwnerInterface $resourceOwner, UserOAuthInterface $oauth)
{
$resourceOwner->getName()->willReturn('google');
$response->getEmail()->willReturn(null);
$response->getUsername()->willReturn('username');
$response->getNickname()->willReturn('user');
$response->getResourceOwner()->willReturn($resourceOwner);
$response->getAccessToken()->willReturn('access_token');
$oauthRepository->findOneBy(array('provider' => 'google', 'identifier' => 'username'))->willReturn(null);
$oauthRepository->createNew()->willReturn($oauth);
$userManager->createUser()->willReturn($user);
$oauth->setIdentifier('username');
$oauth->setProvider('google');
$oauth->setAccessToken('access_token');
$user->getUsername()->willReturn(null);
$user->setUsername('user')->shouldBeCalled();
$user->setPlainPassword('2ff2dfe363')->shouldBeCalled();
$user->setEnabled(true)->shouldBeCalled();
$user->addOAuthAccount($oauth)->shouldBeCalled();
$userManager->updateUser($user)->shouldBeCalled();
$this->loadUserByOAuthUserResponse($response)->shouldReturn($user);
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$username = $response->getUsername();
$email = $response->getEmail();
$nickname = $response->getNickname();
$realname = $response->getRealName();
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $username));
if (null === $user) {
$service = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($service);
$setter_id = $setter . 'Id';
$user = $this->userManager->createUser();
$user->{$setter_id}($username);
$user->setUsername($username);
$user->setRealname($realname);
$user->setNickname($nickname);
$user->setEmail($email);
$user->setPlainPassword($username);
$user->setEnabled(true);
$this->userManager->updateUser($user);
}
return $this->loadUserByUsername($response->getUsername());
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$username = $response->getUsername();
$email = $response->getEmail();
$user = $this->userManager->findUserBy(array('email' => $email));
//when the user is registrating
$service = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($service);
$setter_id = $setter . 'Id';
$setter_token = $setter . 'AccessToken';
if (null === $user) {
// 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($response->getNickname());
$user->setEmail($email);
$user->setPassword($username);
$user->setEnabled(true);
$this->userManager->updateUser($user);
$event = new OAuthResponseEvent($user, $response);
$this->eventDispatcher->dispatch(OesteveUserEvents::REGISTRATION_OAUTH_COMPLETED, $event);
return $user;
}
$user->{$setter_id}($username);
$this->userManager->updateUser($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;
}
/**
* Ad-hoc creation of user.
*
* @param UserResponseInterface $response
*
* @return SyliusUserInterface
*/
protected function createUserByOAuthUserResponse(UserResponseInterface $response)
{
/** @var \Sylius\Component\User\Model\UserInterface $user */
$user = $this->userFactory->createNew();
/** @var CustomerInterface $customer */
$customer = $this->customerFactory->createNew();
$user->setCustomer($customer);
// set default values taken from OAuth sign-in provider account
if (null !== ($email = $response->getEmail())) {
$customer->setEmail($email);
}
if (null !== ($realName = $response->getRealName())) {
$customer->setFirstName($realName);
}
if (!$user->getUsername()) {
$user->setUsername($response->getEmail() ?: $response->getNickname());
}
// set random password to prevent issue with not nullable field & potential security hole
$user->setPlainPassword(substr(sha1($response->getAccessToken()), 0, 10));
$user->setEnabled(true);
return $this->updateUserByOAuthUserResponse($user, $response);
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
return new OAuthUser($response->getNickname(), $response->getEmail());
}
/**
* Set user information from form
*
* @param UserInterface $user
* @param UserResponseInterface $userInformation
*
* @return UserInterface
*/
protected function setUserInformation(UserInterface $user, UserResponseInterface $userInformation)
{
$user->setUsername($this->getUniqueUsername($userInformation->getNickname()));
if (method_exists($user, 'setEmail')) {
$user->setEmail($userInformation->getEmail());
}
return $user;
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$uri = $this->request->getUri();
$isFacebook = false;
$isGoogle = false;
$isLive = false;
$isTwitter = false;
if (strpos($uri, '/login_google') !== false) {
$isGoogle = true;
}
if (strpos($uri, '/login_facebook') !== false) {
$isFacebook = true;
}
if (strpos($uri, '/login_live') !== false) {
$isLive = true;
}
if (strpos($uri, '/login_twitter') !== false) {
$isTwitter = true;
}
if ($isGoogle === false && $isFacebook === false && $isLive === false && $isTwitter === false) {
throw new \Exception("Invalid social network login attempt");
}
$social = "";
if ($isGoogle) {
$social = "google";
}
if ($isFacebook) {
$social = "facebook";
}
if ($isLive) {
$social = "live";
}
if ($isTwitter) {
$social = "twitter";
}
//check to see if the user is logged in and if she is logged in with the same social network
$isLoggedInAlready = $this->session->has('user');
$isLoggedInAlreadyId = $this->session->get('user')['id'];
if ($isLoggedInAlready && $this->session->get('user')['social'] == $social) {
return $this->loadUserByUsername($isLoggedInAlreadyId);
}
$social_id = $response->getUsername();
$nickname = $response->getNickname();
$realName = $response->getRealName();
$email = $response->getEmail();
$avatar = $response->getProfilePicture();
//set data in session. upon logging out we just erase the whole array.
$sessionData = array();
$sessionData['social_id'] = $social_id;
$sessionData['nickname'] = $nickname;
$sessionData['realName'] = $realName;
$sessionData['email'] = $email;
$sessionData['avatar'] = $avatar;
$sessionData['social'] = $social;
$user = null;
if ($isLoggedInAlready) {
$user = $this->doctrine->getRepository('CodeMe\\TheBundle\\Entity\\User')->findOneById($isLoggedInAlreadyId);
} else {
if ($isFacebook) {
$user = $this->doctrine->getRepository('CodeMe\\TheBundle\\Entity\\User')->findOneByFid($social_id);
} else {
if ($isGoogle) {
$user = $this->doctrine->getRepository('CodeMe\\TheBundle\\Entity\\User')->findOneByGid($social_id);
} else {
if ($isLive) {
$user = $this->doctrine->getRepository('CodeMe\\TheBundle\\Entity\\User')->findOneByLid($social_id);
} else {
if ($isTwitter) {
$user = $this->doctrine->getRepository('CodeMe\\TheBundle\\Entity\\User')->findOneByTid($social_id);
}
}
}
}
}
if ($user == null) {
$user = new User();
//change these only the user hasn't been registered before.
$user->setNickname($nickname);
$user->setRealname($realName);
$user->setAvatar($avatar);
}
if ($isFacebook) {
$user->setFid($social_id);
} else {
if ($isGoogle) {
$user->setGid($social_id);
} else {
if ($isLive) {
$user->setLid($social_id);
} else {
if ($isTwitter) {
$user->setTid($social_id);
}
}
}
}
$user->setLastLogin(new \DateTime('now'));
$user->setSocial($social);
// SET E-MAIL
//if all emails are empty, set the first one to this one.
if ($user->getEmail() == "") {
$user->setEmail($email);
} else {
//if it really is an e-mail, try putting it in email2 or email3
if ($email != "") {
//is the e-mail different than the previous one?
if ($email != $user->getEmail()) {
//if there an e-mail in email2? no:
if ($user->getEmail2() == "") {
$user->setEmail2($email);
} else {
//there is an e-mail in email2 and it's different. fall back to setting the user3 to w/e.
if ($user->getEmail2() != $email) {
$user->setEmail3($email);
}
}
}
}
}
//save all changes
$em = $this->doctrine->getManager();
$em->persist($user);
$em->flush();
$id = $user->getId();
//set id
$sessionData['id'] = $id;
$sessionData['is_admin'] = $this->adminChecker->check($user);
$this->session->set('user', $sessionData);
return $this->loadUserByUsername($user->getId());
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$user = new WebHomeUser($response->getNickname(), null, $response->getFirstName(), $response->getLastName(), $response->getLocale(), $response->getAccessToken(), $response->getRefreshToken());
$user->initRolesAndApplications($response->getRoles());
return $user;
}
/**
* {@inheritDoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$rawResponse = $response->getResponse();
$username = $response->getUsername();
$screenName = $response->getNickname();
$service = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($service);
$setter_id = $setter . 'Id';
$setter_token = $setter . 'AccessToken';
$setter_username = $setter . 'Username';
$newUser = false;
$user = $this->userManager->findUserBy(array("{$service}Id" => $username));
if (null === $user) {
switch ($service) {
case 'twitter':
$email = $this->session->get('twitter.email');
if (!$email) {
throw new MissingEmailException();
} else {
$this->session->remove('twitter.email');
}
$defaultUsername = "******";
break;
case 'google':
$email = $rawResponse['email'];
$defaultUsername = $email;
break;
default:
$email = $rawResponse['email'];
$defaultUsername = $email;
break;
}
$newUser = true;
$user = $this->userManager->createUser();
$user->{$setter_id}($username);
$user->{$setter_token}($response->getAccessToken());
$user->{$setter_username}($screenName);
$fullName = explode(' ', $response->getRealName(), 2);
if (isset($fullName[0][1]) && $fullName[0][1] != '') {
$user->setFirstName($fullName[0]);
}
if (isset($fullName[1][1]) && $fullName[1][1] != '') {
$user->setSurname($fullName[1]);
}
if (!UsernameValidator::isUsernameValid($screenName)) {
$screenName = UsernameValidator::getValidUsername();
}
$availableUsername = $this->userManager->getNextAvailableUsername($screenName, 10, $defaultUsername);
$user->setUsername($availableUsername);
$user->setEmail($email);
$user->setPassword('');
$user->setEnabled(true);
$this->userManager->updateCanonicalFields($user);
$form = $this->formFactory->createForm();
$form->setData($user);
$request = $this->container->get('request');
$eventResponse = new \Symfony\Component\HttpFoundation\RedirectResponse('/');
$event = new FormEvent($form, $request);
if ($newUser) {
$this->dispatcher->dispatch(FOSUserEvents::REGISTRATION_SUCCESS, $event);
}
$this->userManager->updateUser($user);
if ($newUser) {
$this->dispatcher->dispatch(FOSUserEvents::REGISTRATION_COMPLETED, new FilterUserResponseEvent($user, $request, $eventResponse));
}
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)
{
return new MyECPUser($response->getUsername(), $response->getNickname(), $response->getEmail(), "https://my.ecp.fr" . $response->getProfilePicture(), $response->getRealName());
}
/**
* Set user information from form
*
* @param UserInterface $user
* @param UserResponseInterface $userInformation
*
* @return UserInterface
*/
protected function setUserInformation(UserInterface $user, UserResponseInterface $userInformation)
{
$accessor = PropertyAccess::createPropertyAccessor();
$accessor->setValue($user, 'username', $this->getUniqueUserName($userInformation->getNickname()));
if (method_exists($accessor, 'isWritable') && $accessor->isWritable($user, 'email')) {
$accessor->setValue($user, 'email', $userInformation->getEmail());
} elseif (method_exists($user, 'setEmail')) {
$user->setEmail($userInformation->getEmail());
}
return $user;
}
protected function getUserInformation(UserResponseInterface $response)
{
$result = ['type' => '', 'id' => '', 'username' => '', 'email' => '', 'avatar' => ''];
$result['type'] = $response->getResourceOwner()->getName();
switch ($result['type']) {
case 'beam':
$result['id'] = $response->getResponse()['id'];
$result['username'] = $response->getNickname();
$result['email'] = $response->getEmail();
$result['avatar'] = $response->getResponse()['avatarUrl'];
break;
case 'twitch':
$result['id'] = $response->getResponse()['_id'];
$result['username'] = $response->getRealName();
//HWIOAuthBundle sets RealName to the user's Twitch Username
$result['email'] = $response->getEmail();
$result['avatar'] = $response->getResponse()['logo'];
break;
case 'gamewisp':
$result['id'] = $response->getResponse()['data']['id'];
$result['username'] = $response->getNickname();
break;
default:
throw new Exception(vsprintf("Unexpected type '%s", [$result['type']]));
}
if (empty($result['id']) === true || empty($result['username']) === true) {
throw new Exception("ID and/or username could not be determined.");
}
$result['access_token'] = $this->getAccessTokenOrNull($result['type'], $result['username'], $response->getAccessToken());
return $result;
}
function it_should_create_new_user_when_none_was_found($userManager, FactoryInterface $customerFactory, FactoryInterface $userFactory, FactoryInterface $oauthFactory, RepositoryInterface $oauthRepository, CustomerInterface $customer, ShopUserInterface $user, UserResponseInterface $response, ResourceOwnerInterface $resourceOwner, UserOAuthInterface $oauth)
{
$resourceOwner->getName()->willReturn('google');
$response->getEmail()->willReturn(null);
$response->getUsername()->willReturn('username');
$response->getNickname()->willReturn('user');
$response->getRealName()->willReturn('Name');
$response->getResourceOwner()->willReturn($resourceOwner);
$response->getAccessToken()->willReturn('access_token');
$response->getRefreshToken()->willReturn('refresh_token');
$oauthRepository->findOneBy(['provider' => 'google', 'identifier' => 'username'])->willReturn(null);
$oauthFactory->createNew()->willReturn($oauth);
$userFactory->createNew()->willReturn($user);
$customerFactory->createNew()->willReturn($customer);
$customer->setFirstName('Name')->shouldBeCalled();
$oauth->setIdentifier('username');
$oauth->setProvider('google');
$oauth->setAccessToken('access_token');
$oauth->setRefreshToken('refresh_token');
$user->setCustomer($customer)->shouldBeCalled();
$user->getUsername()->willReturn(null);
$user->setUsername('user')->shouldBeCalled();
$user->setPlainPassword('2ff2dfe363')->shouldBeCalled();
$user->setEnabled(true)->shouldBeCalled();
$user->addOAuthAccount($oauth)->shouldBeCalled();
$userManager->persist($user)->shouldBeCalled();
$userManager->flush()->shouldBeCalled();
$this->loadUserByOAuthUserResponse($response)->shouldReturn($user);
}
