Python User.add方法代码示例

# 需要导入模块: from models import User [as 别名]
# 或者: from models.User import add [as 别名]
    def run(self, username, password):
        if User.query.filter_by(username=username).first() is not None:
            raise InvalidCommand("User with this username already exists")

        user = User(username, username.title(), password, True)
        user.add(user)
        print ("Superuser `%s` created successfully" % username)

# 需要导入模块: from models import User [as 别名]
# 或者: from models.User import add [as 别名]
 def post(self):
     request_dict = request.get_json()
     if not request_dict:
         response = {'user': 'No input data provided'}
         return response, status.HTTP_400_BAD_REQUEST
     errors = user_schema.validate(request_dict)
     if errors:
         return errors, status.HTTP_400_BAD_REQUEST
     name = request_dict['name']
     existing_user = User.query.filter_by(name=name).first()
     if existing_user is not None:
         response = {'user': 'An user with the same name already exists'}
         return response, status.HTTP_400_BAD_REQUEST
     try:
         user = User(name=name)
         error_message, password_ok = \
             user.check_password_strength_and_hash_if_ok(request_dict['password'])
         if password_ok:
             user.add(user)
             query = User.query.get(user.id)
             result = user_schema.dump(query).data
             return result, status.HTTP_201_CREATED
         else:
             return {"error": error_message}, status.HTTP_400_BAD_REQUEST
     except SQLAlchemyError as e:
         db.session.rollback()
         resp = {"error": str(e)}
         return resp, status.HTTP_400_BAD_REQUEST

# 需要导入模块: from models import User [as 别名]
# 或者: from models.User import add [as 别名]
def add_user():
    username = request.form.get('username', '')
    password = request.form.get('password', '')
    age = request.form.get('age', '')

    #检查用户信息
    _is_ok, _error = User.validate_add(username, password, age)
    if _is_ok:
        User.add(request.form)      #检查ok，添加用户信息
    return json.dumps({'is_ok':_is_ok, "error":_error})

# 需要导入模块: from models import User [as 别名]
# 或者: from models.User import add [as 别名]
    def complete_command(user_state, command_code, chat_message, router):
        view_render_extras = {} #need to add this data to update a view instead of redrawing

        user_view, view_params = router.get_view(user_state, command_code, chat_message.chat_id)

        temp_view_params_text = view_params['text']
        key_code = 0
        sms_code = UserState.get_command_value(chat_message.chat_id, user_state, command_code)
        error = ""
        phone_number = UserState.get_command_value(chat_message.chat_id, user_state, UserState.STATE_UNAUTH_C_GET_PHONE)
        phone_number_formatted = phone_number[0] + '-' + phone_number[1:4] + '-' + phone_number[4:7] + '-' + phone_number[7:]

        if (chat_message.message_type == ChatMessage.UPDATE_TYPE_CALLBACK):
            key_code = int(chat_message.data)
            sms_code, view_render_extras = VerifyPhoneController.update_sms_code_by_callback(chat_message, view_params, sms_code)

        #processing voice message
        elif chat_message.has_voice:
            sms_code, view_render_extras = VerifyPhoneController.update_sms_code_by_audio(chat_message, view_params, sms_code)

        UserState.set_command_value(chat_message.chat_id, user_state, command_code, sms_code)
        sms_code_formatted = ' '.join('{:-<6s}'.format(sms_code))               
        view_params['text'] = view_params['text'].format(phone_number=phone_number_formatted, sms_code=sms_code_formatted, error=error)
        return_value = None        

        #Handling result
        if ((chat_message.message_type == ChatMessage.UPDATE_TYPE_CALLBACK) and (key_code == ViewParams.KEYBOARD_KEY_OK)
            or (chat_message.voice)):
            try:
                AbstractView.show_toast(chat_message.chat_id, MessageText.STATE_AUTH_LOADING, view_render_extras)
                user_obj = AlfaApi.send_sms_code(phone_number, sms_code)  
                
                User.add(chat_id, "access_token", user_obj['access_token'])
                User.add(chat_id, "refresh_token", user_obj['refresh_token'])

                UserState.set_state(chat_message.chat_id, UserState.STATE_NOCARD, UserState.STATE_NOCARD_C_INIT)
                view_params['text'] = MessageText.MESSAGE_CORRECT_CODE
                view_params.update({'force_remove_inline': True})
                return_value = {'run_next': True}

            except AlfaApiError:
                error = ErrorText.ERROR_WRONG_SMS_CODE
                sms_code = ""
                UserState.set_command_value(chat_message.chat_id, user_state, command_code, sms_code)                
                sms_code_formatted = ' '.join('{:-<6s}'.format(sms_code)) 
                view_params['text'] = temp_view_params_text.format(phone_number=phone_number_formatted, sms_code=sms_code_formatted, error=error)

        user_view.render(**view_params)
        return return_value

# 需要导入模块: from models import User [as 别名]
# 或者: from models.User import add [as 别名]
def api_create_user():
    """ Creates a new user, with sign up and login the user. """

    username = request.json.get("username")
    password = request.json.get("password")
    realname = request.json.get("realname")
    if username is None or password is None or realname is None:
        abort(400)  # missing arguments
    if User.query.filter_by(username=username).first() is not None:
        return make_response(jsonify({"error": "User with this username already exists"}), 400)  # existing user
    user = User(username, realname, password, False)
    user.add(user)
    flask_login.login_user(user)
    token = user.generate_auth_token()
    session["token"] = token
    return jsonify({"token": token.decode("ascii")})

# 需要导入模块: from models import User [as 别名]
# 或者: from models.User import add [as 别名]
def signup():
    if request.method == 'GET':
        signup_form = RegistrationForm()
        return render_template('signup.html', error=False, form=signup_form)
    else:
        signup_form = RegistrationForm(request.form)
        if signup_form.validate():
            user = User.add(email=signup_form.email.data,
                password=signup_form.password.data, first_name=signup_form.first_name.data,
                last_name=signup_form.last_name.data, staff=True)
            session['user'] = user.email
            return redirect(url_for('index'))
        else:
            return render_template('signup.html', error=True, form=signup_form)

# 需要导入模块: from models import User [as 别名]
# 或者: from models.User import add [as 别名]
def reg():
    if g.user is not None and g.user.is_authenticated():
        return redirect(url_for('index.home'))

    msg = None
    form = RegForm()
    if form.validate_on_submit():
        email = str(form.email.data)
        user = User.get_by_email(email)
        if user:
            msg = '邮箱已存在，请更换邮箱'
        else:
            user = User.add(str(form.name.data), email, str(form.pwd.data))
            if user:
                login_user(user, bool(form.remember_me))
                return redirect(url_for('index.home'))
            else:
                msg = '注册出错'
    return render_template('account/reg.html', msg=msg, form=form)

# 需要导入模块: from models import User [as 别名]
# 或者: from models.User import add [as 别名]
def user_create_view(request):

    username = request.authenticated_userid

    if request.method == 'POST':

        try:
            manager = BCRYPTPasswordManager()
            username = request.params.get('username')
            password = request.params.get('password')
            hashed = manager.encode(password)
            email = request.params.get('email')
            user = User.add(
                username=username,
                password=hashed,
                email=email,
            )
            Criteria.add(user=user)
            headers = remember(request, username)

            return HTTPFound(request.route_url('send_email'), headers=headers)
        except:
            return {}
    return {'username': username}