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"""
