Notify the provider of the RegisterInfo that the user was now successfuly registered.

Attaches the social-auth user to the newly created user
973133
public function success(UserInterface $user) {
        $repository = App::make('Ipunkt\SocialAuth\Repositories\SocialLoginRepository');
        /**
         * @var SocialLoginRepository $repository
         */
        $login = $repository->create();
        $login->setIdentifier($this->identifier);
        $login->setProvider($this->provider);
        $login->setUser($user->getAuthIdentifier());
        $success = $repository->save($login);
	    if($success)
		    Event::fire('social-auth.register', ['user' => $user, 'registerInfo' => $this]);
	    return $success;
    }
953837
def register():
    """"""

    if _security.confirmable or request.is_json:
        form_class = _security.confirm_register_form
    else:
        form_class = _security.register_form

    if request.is_json:
        form_data = MultiDict(request.get_json())
    else:
        form_data = request.form

    form = form_class(form_data)

    if form.validate_on_submit():
        user = register_user(**form.to_dict())
        form.user = user

        if not _security.confirmable or _security.login_without_confirmation:
            after_this_request(_commit)
            login_user(user)

        if not request.is_json:
            if 'next' in form:
                redirect_url = get_post_register_redirect(form.next.data)
            else:
                redirect_url = get_post_register_redirect()

            return redirect(redirect_url)
        return _render_json(form, include_auth_token=True)

    if request.is_json:
        return _render_json(form)

    return _security.render_template(config_value('REGISTER_USER_TEMPLATE'),
                                     register_user_form=form,
                                     **_ctx('register'))
376594
def register(self):
        
        user, created = self.Model.create_account(self._json_params)
        if user.api_key is None:
            raise JHTTPBadRequest('Failed to generate ApiKey for user')

        if not created:
            raise JHTTPConflict('Looks like you already have an account.')

        self.request._user = user
        headers = remember(self.request, user.username)
        return JHTTPOk('Registered', headers=headers)
89368
def register(**kwargs):
    

    def _wrapper(notification_cls):

        if not issubclass(notification_cls, (Notification,)):
            raise RegisterNotificationError(
                f"Wrapped class must be a 'Notification' class. "
                f"Got '{notification_cls.__name__}'"
            )
        site_notifications.register(notification_cls=notification_cls)
        return notification_cls

    return _wrapper
312996
function _createUser(){
    var newUser = null,
        avatar = '';

        if(this.socialUserInfo.image['60x60']){
            avatar = this.socialUserInfo.image['60x60'].url;
        }

        newUser = {
            role: 'external',
            identities: {
                pinterest: {
                    id: this.socialUserInfo.id,
                    accessToken: this.options.access_token,
                    screen_name: this.socialUserInfo.username
                }
            },
            linkedidentities: ['pinterest'],
            profile: {
                picture: avatar
            },
            displayname: this.socialUserInfo.username,
            enabled: true,
            email: '',
            firstname: this.socialUserInfo.first_name,
            lastname: this.socialUserInfo.last_name
        };

    return db.users.insert(newUser);
}
359163
def add_registration(self, username, first_name, last_name, email, password=""):
        
        register_user = self.appbuilder.sm.add_register_user(
            username, first_name, last_name, email, password
        )
        if register_user:
            if self.send_email(register_user):
                flash(as_unicode(self.message), "info")
                return register_user
            else:
                flash(as_unicode(self.error_message), "danger")
                self.appbuilder.sm.del_register_user(register_user)
                return None
1122935
private function registerNotifyService()
    {
        $this->singleton(Contracts\Notify::class, function ($app) {
            /**  @var \Illuminate\Config\Repository  $config  */
            $config = $app['config'];

            return new Notify(
                $app[Contracts\SessionStore::class],
                $config->get('notify.session.prefix', 'notifier')
            );
        });
    }
539800
def confirm_user(self, user):
        
        if user.confirmed_at is not None:
            return False
        user.confirmed_at = self.security.datetime_factory()
        user.active = True
        self.user_manager.save(user)

        user_confirmed.send(app._get_current_object(), user=user)
        return True
283004
def register
      @user = User.new(require_params)
      if @user.save
        render json: {message: @user, success: true}, status: 201
      else
        render json: {message: @user.errors.full_messages, success: false}, status: :ok
      end
    end
846188
def attach_user            
      render :json => { :success => false, :errors => ['User is not logged in'] } and return if !logged_in?
      @order.customer_id = logged_in_user.id
      render :json => { :success => @order.save, :errors => @order.errors.full_messages, :logged_in => logged_in? }
    end
409361
public function register(UserInterface $user, RegisterInfoInterface $registerInfo) {
		
		$database_profile = $this->socialProfileRepository->findByUserAndProvider($user, 'UserProfile');
		if($database_profile === null) {
			$profile = $registerInfo->getProfile();
			
			$this->copyProfileToDatabase($user, $profile);
			
		}
	}
83274
function updateSigninStatus(isSignedIn) {

        if (isSignedIn) {
            //$("#signInButton").hide();

            var user = gapi.auth2.getAuthInstance().currentUser.get();
            var profile = user.getBasicProfile();
            var username = profile.getName();
            $("#switchUserLink").html("Logged in as: " + username);

        }

    }
239894
def __addUser(self, new_user):
        
        self.__lockReadAddUser.acquire()
        if new_user not in self.__cityUsers and \
                new_user not in self.__excludedUsers:
            self.__lockReadAddUser.release()
            self.__logger.debug("__addUser: Adding " + new_user)
            self.__cityUsers.add(new_user)

            myNewUser = GitHubUser(new_user)
            myNewUser.getData()
            myNewUser.getRealContributions()

            userLoc = myNewUser.location
            if not any(s in userLoc for s in self.__excludedLocations):
                self.__processedUsers.append(myNewUser)
        else:
            self.__logger.debug("__addUser: Excluding " + new_user)
            self.__lockReadAddUser.release()
64989
def register(self, subscriber):
        
        assert isinstance(subscriber, RequestHandler)
        logger.debug('New subscriber')
        self.subscribers.add(subscriber)
770233
public function afterRegistry()
    {
        parent::afterRegistry();

        $this->saveLabel = $this->_('Insert survey');
        $this->tracker   = $this->loader->getTracker();
    }
531911
def insertAnnouncement(self, announcement):
        
        url = announcement.get('url', None)
        try:
            peers.Peer(url)
        except:
            raise exceptions.BadUrlException(url)
        try:
            # TODO get more details about the user agent
            models.Announcement.create(
                url=announcement.get('url'),
                attributes=json.dumps(announcement.get('attributes', {})),
                remote_addr=announcement.get('remote_addr', None),
                user_agent=announcement.get('user_agent', None))
        except Exception as e:
            raise exceptions.RepoManagerException(e)
476214
function registerApp(name, description, permissions) {
  const CONNECTION = new Connection();

  return new Promise((resolve, reject) => {
    CONNECTION.register(name, description, permissions)
      .then(() => resolve(new ConnectionHandler(CONNECTION)))
      .catch((error) => reject(error));
  });
}