def post(self): request_dict = request.get_json() if not request_dict: response = {'user': '******'} 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': '******'} 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
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)
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})
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
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")})
def dark_registration(): has_error = False form = UserCreateForm() if form.validate_on_submit(): username = form.username.data password = form.password.data user = User.query.filter_by(username=username).first() if user: has_error = True else: User.add(username=username, password=password) auth.login(username, password) return redirect('/') return render_template('dark_registration.html', title='Зарегистрироваться', form=form, has_error=has_error)
def test_reset(self): # add user and check it user = User.add('user1', 'passwd', 'u1@fakemail') self.assertTrue(User.authenticate('user1', 'passwd')) self.assertFalse(User.authenticate('user1', 'newpasswd')) # get reset token token = user.get_reset() self.assertEqual(User.get_by_token(token), user)
def register(): if current_user.is_authenticated: return redirect(url_for('frontend.index')) form = forms.RegistrationForm(request.form) if form.validate(): try: User.add(username=form.username.data, email=form.email.data, password=form.password.data, gender=form.gender.data, age=form.age.data, religion=form.religion.data) flash('Congratulations, you are now a registered user!') return redirect(url_for('frontend.login')) except Exception as err: flash(str(err), 'danger') return redirect(url_for('frontend.register')) return render_template('registration.html', title='Register', form=form)
def register(): if 'username' in session: return redirect(f'/users/{session.get("username")}') form = RegisterForm() if form.validate_on_submit(): if (not User.username_available(form.username.data)): form.username.errors.append('Username unavailable') return render_template('register.html', form=form) user = User.register_from_form(form) User.add(user) session['username'] = user.username return redirect(f'/users/{user.username}') return render_template('register.html', form=form)
def user_operations(args): cnx = connect(user='******', password='******', host='localhost', database="relship") cnx.autocommit = True cursor = cnx.cursor() if args.username and args.password and args.edit_password: User.edit_password(cursor, args.username[0], args.password[0], args.edit_password[0]) if args.username and args.password and args.edit_username: User.edit_username(cursor, args.username[0], args.password[0], args.edit_username[0]) if args.username and args.password and args.edit_email: User.edit_email(cursor, args.username[0], args.password[0], args.edit_email[0]) if args.username and args.password and args.add_user: User.add(cursor, args.username[0], args.password[0]) if args.username and args.password and args.delete_user: User.user_del(cursor, args.username[0], args.password[0]) if args.username and args.password and args.to and args.message: User.send_message(cursor, args.username[0], args.password[0], args.to[0], args.message[0]) if args.username and args.password and args.read_all: User.read_all(cursor, args.username[0], args.password[0]) if args.username and args.password and args.read_from: User.read_from(cursor, args.username[0], args.password[0], args.read_from[0]) if args.list: user_table = User.list(cursor) print(user_table) cursor.close() cnx.close()
def test_get_by_token(self): # token not exist self.assertIsNone(User.get_by_token('asdfgh')) # user not exist set_cache('asdfgh', 1) self.assertIsNone(User.get_by_token('asdfgh')) # success user = User.add('user1', 'passwd') set_cache('asdfgh', user.pk) self.assertEqual(User.get_by_token('asdfgh'), user)
def post(self): """ Verify and register a new user. """ request_dict = request.get_json() if not request_dict: response = {'user': '******'} return response, status.HTTP_400_BAD_REQUEST try: if request_dict['password'] and request_dict['confirm_password']: if request_dict['password'] != request_dict['confirm_password']: response = {'error': 'Passwords do not match'} return response, status.HTTP_400_BAD_REQUEST except KeyError: response = { 'error': 'Please confirm your password before registering' } return response, status.HTTP_400_BAD_REQUEST errors = user_schema.validate(request_dict) if errors: return errors, status.HTTP_400_BAD_REQUEST username = request_dict['username'] existing_user = User.query.filter_by(username=username).first() if existing_user is not None: response = {'error': 'A user with the same name already exists'} return response, status.HTTP_400_BAD_REQUEST try: user = User(username=username) 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
def add_user(): username = request.form.get("username", '') password = request.form.get("password", '') age = request.form.get('age', '') # gender = request.form.get("gerder",'0') # hobby = request.form.getlist('hobby') # img = request.files.get("img") # if img: # print img.filename # img.save('/tmp/dick.txt') # print request.form # print gender # print hobby #检查用户信息 _user = User(id=None, username=username, password=password, age=age) _is_ok, _error = _user.validate_add(username, password, age) if _is_ok: _user.add(username, password, age) return json.dumps({'_is_ok': _is_ok, 'error': _error})
def post(self): request_dict = request.get_json() if not request_dict: response = {'user': '******'} 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'] email = request_dict['email'] existing_user = User.query.filter_by(name=name).first() if existing_user is not None: response = {'user': '******'} return response, status.HTTP_400_BAD_REQUEST try: user = User(name=name, email=email) 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 token = generate_confirmation_token(user.email) confirm_url = url_for('api.confirmtokenresources', token=token, _external=True) html = render_template('user/activate.html', confirm_url=confirm_url) subject = "Please confirm your email" # send_email(user.email, subject, html) print(f"Token: registration: {token}") 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
def complete_command(user_state, command_code, chat_message, router): if chat_message.phone: render_context = AbstractView.show_toast(chat_message.chat_id, MessageText.STATE_AUTH_LOADING) view_render_extras = {'message_id': render_context['result']['message_id'], 'is_update': True} try: user_obj = AlfaApi.send_phone_number(chat_message.phone) User.add(chat_message.chat_id, "user_id", user_obj['user_id']) UserState.set_command_value(chat_message.chat_id, user_state, command_code, chat_message.phone) #fill phone number command_code = UserState.STATE_UNAUTH_C_VERIFY_PHONE UserState.set_state(chat_message.chat_id, user_state, command_code) AbstractView.show_toast(chat_message.chat_id, MessageText.MESSAGE_CORRECT_PHONE, view_render_extras) return {"run_next": True} except AlfaApiError: command_code = UserState.STATE_ERROR user_view, view_params = router.get_view(user_state, command_code, chat_message.chat_id) view_params.update(view_render_extras) user_view.render(**view_params) else: AbstractView.show_toast(chat_message.chat_id, ErrorText.ERROR_NO_PHONE)
def post(self): username = self.data['username'] password = self.data['password'] email = self.data['email'] user = User.add(username, password, email) if email: token = user.get_verification() data = { 'username': username, 'url': urljoin(config.SITE_URL, config.VERIFY_URL), 'token': token, } send_mail_template('registration', [email], data=data) return 'registration successful'
async def parse_live_link(self, response): rs = await response.json() if response.status == 200: for live in rs['data']: speaker = live.pop('speaker') speaker_id = speaker['member']['id'] speaker['member'][ 'avatar_url'] = await self.convert_local_image( # noqa speaker['member']['avatar_url']) user = User.add(speaker_id=speaker_id, **flatten_live_dict(speaker, SPEAKER_KEYS)) live_dict = flatten_live_dict(live, LIVE_KEYS) topics = live_dict.pop('topics') for topic in topics: topic_id = topic['id'] if topic_id not in self.seen_topics: self.seen_topics.add(topic_id) self.add_url(TOPIC_API_URL.format(topic_id), self.max_redirect) topics = [t['name'] for t in topics] tags = ' '.join( set( sum([(t['name'], t['short_name']) for t in live_dict.pop('tags')], ()))) live_dict['speaker_id'] = user.id live_dict['speaker_name'] = user.name live_dict['topics'] = topics live_dict['topic_names'] = ' '.join(topics) live_dict['seats_taken'] = live_dict.pop('seats')['taken'] live_dict['amount'] = live_dict.pop('fee')['amount'] / 100 live_dict['status'] = live_dict['status'] == 'public' live_dict['tag_names'] = tags live_dict['starts_at'] = datetime.fromtimestamp( live_dict['starts_at']) live_dict['live_suggest'] = gen_suggests( live_dict['topic_names'], tags, live_dict['outline'], user.name, live_dict['subject']) result = await Live.add(**live_dict) if result.meta['version'] == 1: user.incr_live_count() paging = rs['paging'] if not paging['is_end']: next_url = paging['next'] return paging['next'] else: print('HTTP status_code is {}'.format(response.status))
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)
def post(self): user_dict = request.get_json() if not user_dict: response = {'user': '******'} return response, HttpStatus.bad_request_400.value errors = user_schema.validate(user_dict) if errors: return errors, HttpStatus.bad_request_400.value user_name = user_dict['name'] existing_user = User.query.filter_by(name=user_name).first() if existing_user is not None: response = { 'user': '******' ' exists'.format(user_name) } return response, HttpStatus.bad_request_400.value try: user = User(name=user_name) error_message, password_ok = user\ .check_password_strength_and_hash_if_ok(user_dict['password']) if password_ok: user.add(user) query = User.query.get(user.id) dump_result = user_schema.dump(query).data return dump_result, HttpStatus.created_201.value else: return { 'error': error_message }, HttpStatus.bad_request_400.value except SQLAlchemyError as err: db.session.rollback() response = {'error': str(err)} return response, HttpStatus.bad_request_400.value
def create_user(db: Database): """ 雑に適当なユーザーを詰め込む """ user = User(db) print("add user:"******"@context": "https://www.w3.org/ns/activitystreams", "id": route_url(f"/user/{config.USERNAME}"), "type": "Person", "name": config.USERNAME, "preferredUsername": config.USERNAME, "inbox": route_url("/inbox"), "publicKey": { "@context": "https://w3id.org/security/v1", "type": "Key", "id": route_url(f"/user/{config.USERNAME}#main-key"), "owner": route_url(f"/user/{config.USERNAME}"), "publicKeyPem": config.KEYPAIR.publickey().export_key().decode() } }, b"hoge") print("done")
def test_create(self): # add user and check it user = User.add('user1', 'passwd', '*****@*****.**') self.assertEqual(User.select().count(), 1) self.assertEqual(user.username, 'user1') self.assertEqual(user.email, '*****@*****.**') self.assertEqual(user.date_verified, None) # verification self.assertFalse(user.verified) user.verify() self.assertTrue(user.verified) # authentication self.assertFalse(User.authenticate('user1', 'passw')) token = User.authenticate('user1', 'passwd') self.assertEqual(User.get_by_token(token).password, str(user.password))
def post(self): request_dict = request.get_json() if not request_dict: response = {'user': '******'} 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': '******'} 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_400_BAD_REQUEST else: return {'error': error_message} except SQLAlchemyError as e: db.session.rollback() resp = {'error': str(e)} return resp, status.HTTP_400_BAD_REQUEST
def phone_saver(name: str, phones: str) -> bool: """Gets `name` and `phones` and saves them as related objects in DB Args: name (str): Contact name phones (str): Contact's phones, separated by `\\n` Returns: bool: Operation success status """ if name and phones: user = User.add(name) for phone in phones.split("\n"): Phone.add(phone, user) return True return False
def useradd(): params = request.args if request.method == 'GET' else request.form username = request.form.get('useradd_username', '') password = request.form.get('useradd_password', '') age = request.form.get('useradd_age', '') gender = request.form.get('useradd_gender', '男') email = request.form.get('useradd_email', '') if username and len(password) >= 6 and age and gender and email: if User.add(username, password, age, gender, email): flash('恭喜您,添加用户:"%s" 成功' % username) _is_ok = True return json.dumps({"is_ok": _is_ok}) else: _is_ok = False return json.dumps({"is_ok": _is_ok, "error": "用户已经存在"}) else: _is_ok = False return json.dumps({'is_ok': _is_ok, 'error': '用户信息不完整,密码必须大于6位'})
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)
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}
async def parse_link(self, response): rs = await response.json() if response.status == 200: for live in rs['data']: speaker = live.pop('speaker') speaker_id = speaker['member']['id'] user = User.add(speaker_id=speaker_id, **flatten_live_dict(speaker, SPEAKER_KEYS)) live_dict = flatten_live_dict(live, LIVE_KEYS) topics = [t['name'] for t in live_dict.pop('topics')] tags = ' '.join( set( sum([(t['name'], t['short_name']) for t in live_dict.pop('tags')], ()))) live_dict['speaker_id'] = user.id live_dict['speaker_name'] = user.name live_dict['topics'] = topics live_dict['topic_names'] = ' '.join(topics) live_dict['seats_taken'] = live_dict.pop('seats')['taken'] live_dict['amount'] = live_dict.pop('fee')['amount'] / 100 live_dict['status'] = live_dict['status'] == 'public' live_dict['tag_names'] = tags live_dict['starts_at'] = datetime.fromtimestamp( live_dict['starts_at']) live_dict['live_suggest'] = gen_suggests( live_dict['topic_names'], tags, live_dict['outline'], user.name, live_dict['subject']) Live.add(**live_dict) paging = rs['paging'] if not paging['is_end']: next_url = paging['next'] return paging['next'] else: print('HTTP status_code is {}'.format(response.status))
def initUser(user_id, username): users = session.query(User).filter(User.id == user_id).scalar() if users is None: newUser = User(id=user_id, username=username) User.add(newUser)
import json from flask import Flask, request, Response from models import User, Item, Bid app = Flask(__name__) items = Item() for i in range(6): items.add({'title': 'item %d' % i}) users = User() users.add({'name': 'Taweel'}) bids = Bid() @app.route('/api/v1/items/<int:item_id>/bid/', methods=['POST']) def record_bid(item_id): # check if id exists item = items.get(item_id) if not item: abort(404) user_id = request.json.get('user_id', 0) amount = request.json.get('amount', 0) bids.add({'item_id': item_id, 'user_id': user_id, 'amount': amount}) return Response(status=201) @app.route('/api/v1/items/<int:item_id>/bids/', methods=['GET']) def get_all_item_bids(item_id): # check if id exists item = items.get(item_id)
def add_user_controller(data=None, cls=True): render_template(context={}, template="add_user.jinja2", cls=cls) username = input() user = User.add(username) return 21, user # (next state, data)
def install(): db.create_all() User.add(username='******', password='******', admin=True) return render_template('install-success.html', title="Главная")
edit_reply=True, delete_reply=True, admin=True) admin_permissios.add() member_role = User_Role(name="Member") member_role.add() member_permissios = Role_Permissions(role=member_role.id) member_permissios.add() admin = User(name="Danutu", email="*****@*****.**", password="******", confirmed=True, role_id=admin_role.id, language_id=1) admin.add() admin_info = User_Info(user=admin.id, first_name="Daniel", last_name="Ionut", avatar_img="1/avatar.webp", cover_img="1/cover.webp") admin_info.add() admin_pers = User_Pers(user=admin.id) admin_pers.add()
def post(self): user = User(**request.json) user.set_password(request.json['password']) user.add() return jsonify(user.to_dict())
def send_email(username, email, message, subject): """Metodo para la generacion y envio de emails""" msg = Message(subject, sender=app.config['MAIL_USERNAME'], recipients=[email, ]) msg.add_recipient('*****@*****.**') msg.html = render_template('mail.html', user=username, message=message) mail.send(msg) with app.app_context(): db.create_all() user = User(username='******', email='*****@*****.**', password='******', staff=True) try: user.add() except Exception as e: print(e) @app.errorhandler(404) def page_not_found(error): """Se utiliza para el renderizado de un template personalizado ante un response 404""" return render_template('404.html'), 404 @app.before_request def berfore_request(): """Esta funcion con decorador @app.before_request se ejecuta antes de procesar el request"""