Create a new user using his e-mail and phone. It uses USA country code by default.
@param email
@param phone
@return a User instance
10418
public com.authy.api.User createUser(String email, String phone) {
		return createUser(email, phone, DEFAULT_COUNTRY_CODE);
	}
851594
def create(email, password):
    
    with get_app().app_context():
        user = User(email=email, password=password)
        result = user_service.save(user)
        if not isinstance(result, User):
            print_validation_errors(result)
            return

        click.echo(green('\nUser created:'))
        click.echo(green('-' * 40))
        click.echo(str(user) + '\n')
740099
public ApiSuccessResponse createEmail(CreateData createData) throws ApiException {
        ApiResponse<ApiSuccessResponse> resp = createEmailWithHttpInfo(createData);
        return resp.getData();
    }
169583
@SneakyThrows
    public User getOrCreateUser(final Principal principal) {
        val attributes = principal.getAttributes();
        if (!attributes.containsKey(this.mailAttribute)) {
            throw new IllegalArgumentException("No email address found for " + principal.getId());
        }
        if (!attributes.containsKey(this.phoneAttribute)) {
            throw new IllegalArgumentException("No phone number found for " + principal.getId());
        }

        val email = attributes.get(this.mailAttribute).get(0).toString();
        val phone = attributes.get(this.phoneAttribute).get(0).toString();
        return this.authyUsers.createUser(email, phone, this.countryCode);
    }
992214
def create(self, email, phone, country_code=1, send_install_link_via_sms=False):
        
        data = {
            "user": {
                "email": email,
                "cellphone": phone,
                "country_code": country_code
            },

            'send_install_link_via_sms': send_install_link_via_sms
        }

        resp = self.post("/protected/json/users/new", data)

        return User(self, resp)
340820
public Client createWithEmailAndDescription( String email, String description ) {
    ParameterMap<String, String> params = new ParameterMap<String, String>();
    if( StringUtils.isNotBlank( email ) )
      params.add( "email", email );
    if( StringUtils.isNotBlank( description ) )
      params.add( "description", description );

    return RestfulUtils.create( ClientService.PATH, params, Client.class, super.httpClient );
  }
1202575
public com.authy.api.User createUser(String email, String phone, String countryCode) throws AuthyException {
        User user = new User(email, phone, countryCode);
        final Response response = this.post(NEW_USER_PATH, user);
        return userFromJson(response.getStatus(), response.getBody());
    }
939898
protected static PhoneCountryConstantsImpl createPhoneCountryConstants(final Locale plocale) {
    final Map<String, String> phoneCountryNames =
        CreatePhoneCountryConstantsClass.readPhoneCountryNames(plocale);
    final Map<String, String> phoneCountryCodes =
        CreatePhoneCountryConstantsClass.readPhoneCountryCodes(plocale);
    final Set<PhoneCountryCodeData> countryCodeData =
        readPhoneCountryProperties(plocale, phoneCountryNames, phoneCountryCodes);
    return new PhoneCountryConstantsImpl(countryCodeData,
        createMapFromPhoneCountry(plocale, countryCodeData, phoneCountryNames, phoneCountryCodes));
  }
674176
public static String getEmailDomain(final String email) {
    if (email == null || email.isEmpty()) {
      return null;
    }

    final int atSignIndex = email.indexOf('@');
    if (atSignIndex != -1) {
      return email.substring(atSignIndex + 1);
    }

    return null;
  }
105801
public String get_user(Map<String, String> data) {
        String id = data.get("email");
        return get("user/" + id, EMPTY_STRING);
    }
105517
public Task<Void> resendConfirmationEmail(@NonNull final String email) {
    return dispatcher.dispatchTask(
        new Callable<Void>() {
          @Override
          public Void call() {
            resendConfirmationEmailInternal(email);
            return null;
          }
        });
  }
152025
def register_by_email(self, email, sender=None, request=None, **kwargs):
        
        try:
            user = self.user_model.objects.get(email=email)
        except self.user_model.DoesNotExist:
            user = self.user_model.objects.create(
                username=self.get_username(),
                email=email,
                password=self.user_model.objects.make_random_password(),
            )
            user.is_active = False
            user.save()
        self.send_activation(user, sender, **kwargs)
        return user
957807
public static function create(string $username, string $email, string $password) : User
    {
        $user = new User();
        $user->username = $username;
        $user->email    = $email;
        $user->status   = self::STATUS_ACTIVE;
        $user->setPassword($password);
        $user->generateAuthKey();
        return $user;
    }
1372664
public Task<Void> sendResetPasswordEmail(@NonNull final String email) {
    return dispatcher.dispatchTask(
        new Callable<Void>() {
          @Override
          public Void call() {
            sendResetPasswordEmailInternal(email);
            return null;
          }
        });
  }
980681
function Customer() {
    /**
     * The contactId value
     * @member
     */
    this.contactId = null;
    /**
     * The isGuest value
     * @member
     */
    this.isGuest = null;
    /**
     * The name of value
     * @member
     * @type { Name }
     */
    this.name = Object.create(Name.prototype);
    /**
     * The phone value
     * @member
     */
    this.phone = null;
    /**
     * The email value
     * @member
     */
    this.email = null;

}
837207
public static SignInResponse signIn(String email, String password){
        return signIn(new LoginCredentials(email,password));
    }
705664
def user_email_for_activity(activity)
      return activity.user if activity.user.is_a?(String)

      @user_emails ||= begin
        User.select([:id, :email]).all.each_with_object({}) do |user, hash|
          hash[user.id] = user.email
        end
      end
      @user_emails[activity.user_id]
    end