/**
* {@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)
{
$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();
$email = $response->getEmail();
$nickname = $response->getRealName();
//var_dump($email); die();
$user = $this->userManager->findUserByUsernameOrEmail($email);
//$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->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;
}
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());
}
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);
}
/**
* @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)
{
$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)
{
/** @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;
}
/**
* {@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 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());
}
private function register(UserResponseInterface $response)
{
$username = $response->getRealName();
$email = $response->getEmail();
$password = $response->getUsername();
$service = $response->getResourceOwner()->getName();
$client = $this->container->get('doctrine')->getRepository('BoundCoreBundle:Client')->findOneBy(array($service . '_id' => $password));
if ($client instanceof Client) {
$this->session->getFlashBag()->add('error', "Client ID already bound.");
} else {
$user = $this->container->get('bound.user_manager')->add($username, $email, $password, true);
$this->link($response, $user);
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)
{
$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) {
if (empty($response->getEmail())) {
$message = sprintf("User not found. Please register first and then connect the account from your profile.", $username);
throw new AccountNotLinkedException($message);
}
$fullName = $response->getRealName();
$parts = explode(" ", $fullName);
$lastname = array_pop($parts);
$firstname = implode(" ", $parts);
$user = $this->userManager->createUser();
$user->setEnabled(true);
$user->setUsername($response->getUsername());
$user->setEmail($response->getEmail());
$user->setPlainPassword(bin2hex(random_bytes(5)));
$user->setFirstName($firstname);
$user->setLastName($lastname);
$this->userManager->updateUser($user);
$connection = new UserOauthAccount();
$connection->setUser($user);
$connection->setProvider($service);
$connection->setProviderId($response->getUsername());
}
$connection->setToken($response->getAccessToken());
$this->em->persist($connection);
$this->em->flush();
return $connection->getUser();
}
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)
{
$userTokenId = $response->getUsername();
// it is user id in social network
// $email = $response->getEmail();
$userNameLastName = $response->getRealName();
// name + lastname
$userNameLastName = explode(" ", $userNameLastName);
$service = $response->getResourceOwner()->getName();
switch ($service) {
case "facebook":
if (count($userNameLastName) > 1) {
$realName = $userNameLastName[0];
$realLastName = $userNameLastName[1];
} else {
$realName = $userNameLastName[0];
$realLastName = null;
}
break;
case "vkontakte":
if (count($userNameLastName) > 1) {
$realName = $userNameLastName[1];
$realLastName = $userNameLastName[0];
} else {
$realName = $userNameLastName[0];
$realLastName = null;
}
break;
default:
if (count($userNameLastName) > 1) {
$realName = $userNameLastName[0];
$realLastName = $userNameLastName[1];
} else {
$realName = $userNameLastName[0];
$realLastName = null;
}
break;
}
// Lets create toke service _ id (for example 213123424_facebook)
$accessToken = $userTokenId . "_" . $service;
// find by name
$user = $this->userManager->findUserBy(array("username" => $accessToken));
//when the user is registrating
if (null === $user) {
try {
// create new user here
$user = $this->userManager->createUser();
$user->setUsername($accessToken);
$user->setFirstname($realName);
if (!is_null($realLastName)) {
$user->setLastname($realLastName);
}
//email can be null
// Lets use default email
$user->setEmail($accessToken . "@table4you.com");
// encode password
$factory = $this->container->get('security.encoder_factory');
$encoder = $factory->getEncoder($user);
$password = $encoder->encodePassword($userTokenId, $user->getSalt());
$user->setPassword($password);
$user->setEnabled(true);
if (null === $user->getConfirmationToken()) {
/** @var $tokenGenerator \FOS\UserBundle\Util\TokenGeneratorInterface */
$tokenGenerator = $this->container->get('fos_user.util.token_generator');
$user->setConfirmationToken($tokenGenerator->generateToken());
}
$this->userManager->updateUser($user);
// We should send confirmation email
// $mailer = $this->container->get('fos_user.mailer');
// $mailer->sendConfirmationEmailMessage($user);
return $user;
} catch (Exception $ex) {
throw new AccessDeniedException();
}
}
//if user exists - go with the HWIOAuth way
return $user;
}
/**
* {@inheritdoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$username = $response->getUsername();
$fbUsername = $response->getRealName();
$fbNickname = $response->getNickname();
//echo $fbGender = $response->getResponse()->getFirstName();
/*echo $fbNickname = $response->getBirthDate();*/
$fbUserEmail = $response->getEmail();
//echo "<pre>";
//print_r($response->getResponse());
//print_r($response);
//echo "</pre>";
$resArray = $response->getResponse();
$fbPic = $resArray['picture']['data']['url'];
$fbName = $resArray['name'];
$fbGender = $resArray['gender'];
$fbLanguages = $resArray['languages']['0']['name'];
$fbLocation = $resArray['location']['name'];
$fbHometown = $resArray['hometown']['name'];
$str = $fbPic . '-' . $fbName . '-' . $fbGender . '-' . $fbLanguages . '-' . $fbLocation . '-' . $fbHometown;
//exit('ff');
$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($username);
//case to handle for blank username
if (preg_match('/\\s/', $fbNickname)) {
$no = rand(1, 99999);
$fbNickname = $fbNickname . $no;
}
$user->setUsername(str_replace(' ', '', $fbNickname));
$user->setName($fbUsername);
if (isset($fbUserEmail)) {
$user->setEmail($response->getEmail($fbUserEmail));
//exit('defined');
} else {
$user->setEmail($username);
//exit('undef');
}
//$user->setEmail($username);
$user->setCity($fbLocation);
$user->setLocale($fbLanguages);
$user->setFacebookName($fbName);
$user->setGender($fbGender);
$user->setBiography($str);
$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;
}
private function getUserInfo(UserResponseInterface $response)
{
$fullName = explode(' ', $response->getRealName(), 2);
$userInfo = ['id' => $response->getUsername(), 'email' => $response->getEmail(), 'username' => $response->getNickname(), 'first_name' => $fullName[0], 'family_name' => $fullName[1], 'access_token' => $response->getAccessToken()];
return $userInfo;
}
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);
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$socialID = $response->getUsername();
/** @var User $user */
$user = $this->userManager->loadUser(['facebookId' => $socialID]);
$update = true;
$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->loadUser($email, 'email');
if (null === $user || !$user instanceof UserInterface) {
//if the user does not have a normal account, set it up:
/** @var User $user */
$name = $response->getNickname() ?? $response->getRealName();
$user = $this->userManager->createUser($name, md5(uniqid()), $response->getEmail(), ['ROLE_OAUTH_USER']);
$user->setEmail($email);
$user->setFullName($name);
$user->setEnabled(true);
$violations = $this->validator->validate($user);
$update = !$violations->count() === 0;
if ($violations->count() === 0) {
$this->session->getFlashBag()->add('warning', 'Welcome! You must complete your profile in order to use the features on the site.');
} else {
throw new CustomUserMessageAuthenticationException('An account in your name already exists.');
}
}
if ($update) {
//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
$token = new UsernamePasswordToken($user, null, 'main', $user->getRoles());
$this->tokenStorage->setToken($token);
}
$user->setLastLoggedIn(new \DateTime());
$this->userManager->updateUser($user);
return $user;
}
/**
* Create a new user from a response
*
* @param UserResponseInterface $response
*
* @return UserInterface
*/
protected function createUser(UserResponseInterface $response)
{
/**
* @var CustomerInterface $customer
*/
$customer = $this->customerDirector->create();
$customer->setEmail($response->getEmail())->setFirstname($response->getRealName());
$this->customerDirector->save($customer);
$this->userEventDispatcher->dispatchOnCustomerRegisteredEvent($customer);
return $customer;
}
/**
* {@inheritDoc}
*/
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
return new MyECPUser($response->getUsername(), $response->getNickname(), $response->getEmail(), "https://my.ecp.fr" . $response->getProfilePicture(), $response->getRealName());
}
/**
* {@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)
{
$sessionArr = $this->session->all();
$resourceOwnerName = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($resourceOwnerName);
$setter_id = $setter . 'Id';
$setter_token = $setter . 'AccessToken';
if (!isset($this->properties[$resourceOwnerName])) {
throw new \RuntimeException(sprintf("No property defined for entity for resource owner '%s'.", $resourceOwnerName));
}
$username = $response->getUsername();
if (isset($sessionArr['_security_secured_area'])) {
//when user already logged and connect with other social network
$instance = unserialize($sessionArr['_security_secured_area']);
$user = $this->repository->findOneById($instance->getUser()->getId());
if (!$user instanceof Actor) {
throw new \RuntimeException("_security_secured_area key exist but any user have been stored ");
}
$user->{$setter_id}($username);
$user->{$setter_token}($response->getAccessToken());
$this->em->flush();
return $user;
} else {
//when user not logged and connect with other social network
$user = $this->repository->findOneBy(array($this->properties[$resourceOwnerName] => $username));
if (null === $user && $resourceOwnerName != 'twitter') {
$user = $this->repository->findOneBy(array('email' => $response->getEmail()));
}
//when the user is registrating
if (null === $user) {
// create new user here
$user = new Actor();
$user->{$setter_id}($username);
$user->{$setter_token}($response->getAccessToken());
//Encode pass
$encoder = $this->encoderFactory->getEncoder($user);
$password = $encoder->encodePassword($username, $user->getSalt());
$user->setPassword($password);
//Add ROLE
$role = $this->em->getRepository('CoreBundle:Role')->findOneBy(array('role' => 'ROLE_USER'));
$user->addRole($role);
//I have set all requested data with the user's username
//modify here with relevant data
if (isset($oauthData['name'])) {
$user->setName($oauthData['name']);
} else {
$user->setName($username);
}
$user->setUsername($username);
if ($resourceOwnerName == 'twitter') {
$user->setEmail($username);
} else {
$user->setEmail($response->getEmail());
}
$user->setIsActive(true);
$this->em->persist($user);
$this->em->flush();
}
//we need response data to update or fill: username, name, profile image
$this->updateOAuthData($user, array('owner' => $resourceOwnerName, 'id' => $username, 'name' => $response->getRealName(), 'profileImage' => $response->getProfilePicture()));
return $user;
}
// return $user;
}
protected function loadTwitterUser(UserResponseInterface $response)
{
$user = $this->userManager->createUser();
$user->setUsername($response->getUsername());
$user->setEmail($response->getEmail());
$user->setLastName($response->getRealName());
$user->setFirstName($response->getNickName());
$user->setType($response->getResourceOwner()->getName());
$user->setAccessToken($response->getAccessToken());
$user->setLocale($response->getLocale());
if (is_null($user->getLocale())) {
$user->setLocale('fr');
}
$user->setRoles(['ROLE_USER']);
$user->setPassword('');
$user->setEnabled(true);
$user->setCreatedAt(new \DateTime());
$user->setUpdatedAt(new \DateTime());
$this->userManager->updateUser($user);
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)
{
// First, check if it's an Azure User
if (get_class($response->getResourceOwner()) != "HWI\\Bundle\\OAuthBundle\\OAuth\\ResourceOwner\\AzureResourceOwner") {
throw new UnsupportedUserException("Can not load a user by " . get_class($response->getResourceOwner()) . ".");
}
// Check if this user exists
$user = $this->userManager->findUserByEmail($response->getEmail());
// Load groups ids
$groups = $this->entityManager->createQueryBuilder()->select("azureRole.azureGid")->from("BdEMainBundle:AzureRole", 'azureRole')->getQuery()->getArrayResult();
$request = ['groupIds' => []];
foreach ($groups as $group) {
$request['groupIds'][] = $group['azureGid'];
}
// Load groups for this user
$client = new Curl();
$client->setTimeout(20000);
$client = new Browser($client);
$uid = $response->getResponse()['oid'];
$uri = "https://graph.windows.net" . "/" . $this->tenant . "/me/checkMemberGroups?api-version=1.6";
$r = $client->post($uri, array("Authorization: Bearer " . $response->getAccessToken() . "", "Content-Type: application/json", "Accept: application/json"), json_encode($request));
$r = json_decode($r->getContent());
$groups = $r->value;
$roleRepo = $this->entityManager->getRepository("BdEMainBundle:AzureRole");
/** @var AzureRole[] $azureRoles */
$azureRoles = $roleRepo->createQueryBuilder('azureRole')->where('azureRole.azureGid IN (?1)')->setParameter(1, $groups)->getQuery()->getResult();
/** @var Role[] $roles */
$roles = array();
foreach ($azureRoles as $azureRole) {
$roles = array_merge($roles, $azureRole->getRoles());
}
$roles = array_unique($roles);
if (sizeof($roles) == 0) {
// Try to get if it's a SuperAdmin
$uri = "https://graph.windows.net" . "/" . $this->tenant . "/me/memberOf?api-version=1.6";
$r = $client->get($uri, array("authorization: Bearer " . $response->getAccessToken()));
$userRoles = json_decode($r->getContent());
if (!property_exists($userRoles, 'value')) {
throw new UsernameNotFoundException(sprintf("Impossible to log you !", $response->getRealName()));
}
$userRoles = $userRoles->value;
foreach ($userRoles as $userRole) {
if ($userRole->objectType == 'Role') {
if ($userRole->displayName == "Company Administrator" && strpos($response->getEmail(), $this->tenant) !== false) {
// We found an Admin !
$roles[] = new Role("ROLE_SUPER_ADMIN");
break;
}
}
}
if (count($roles) == 0) {
$this->flashBag->add("error", $response->getEmail() . " ne peut pas se connecter à cette application");
throw new UsernameNotFoundException(sprintf("User '%s' has no power here!", $response->getRealName()));
}
}
/** @var User $user */
if ($user == null) {
$user = $this->userManager->createUser();
}
$user->setRoles($roles);
$user->setEmail($response->getEmail());
$user->setEmailCanonical($response->getEmail());
$user->setEnabled(true);
$user->setUsername($response->getEmail());
$user->setPlainPassword($response->getAccessToken());
$user->setAzureAccessToken($response->getAccessToken());
$user->setAzureRenewAccessToken($response->getRefreshToken());
$this->userManager->updateUser($user);
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;
}
/**
* 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);
}
protected function loadGithubUser(UserResponseInterface $response)
{
$username = $response->getUsername();
$user = $this->userManager->createUser();
$user->setGithubId($username);
$user->setGithubAccessToken($response->getAccessToken());
$email = $response->getEmail();
$user->setUsername($email);
$user->setName($response->getRealName());
$user->setPassword('');
$user->setEmail($email);
$user->setEnabled(true);
$this->userManager->updateUser($user);
return $user;
}
