def put_user(user_id):
data = {
'password': request.form['password'],
'level': request.form['level']
}
print(data)
User.modify_user(user_id, data)
return jsonify({}), 200
def create_user():
user = {'id': request.form['id'],
'username': request.form['username'],
'password': request.form['password'],
'level': request.form['level'],
}
User.create_user(user)
return jsonify({}), 200
def login():
print('hehe' * 10, request.args, request.form)
(username, password) = (request.form['username'], request.form['password'])
is_user = User.verify_user(username, password)
if is_user:
user = User.get_user_by_name(username)
return jsonify({
'_id': user['_id'],
'name': user['name'],
'level': user['level']
}), 200
else:
return json.dumps({'msg': '账号和密码不匹配', 'errorCode': 'error_args'}), 401
async def post(self):
try:
data = await self.request.json()
except:
raise exceptions.InvalidRequestException('No json send')
context = {
'db_session': self.request.db_session,
'ws_session': {'tz': data.get('user_timezone')},
'method': 'create',
'queue': self.request.app.queue
}
# INIT USER
user = User()
context['data'] = data
sane_data = await user.sanitize_data(context)
context['data'] = sane_data
await user.validate_and_save(context)
# SET SESSION
await set_session(user, self.request)
session = await get_session(self.request)
session['tz'] = data.get('user_timezone')
context['method'] = 'read'
context['user'] = user
context['ws_session'] = session
resp_data = {
'success': True,
'user': await user.serialize(context),
'token': session['csrf_token']
}
return web.json_response(resp_data)
def create_new_user(email, password, nickname, age):
new_user = User(email=email,
password=generate_password_hash(password),
nickname=nickname,
age=age)
session.add(new_user)
session.commit()
def create_user(self, data=user):
'''
Function that presists a User in the database for the test
'''
user = User(
email=data['email'],
name=data['name'],
surname=data['surname'],
admin=data['admin'],
admin_privileges_by=data['admin_privileges_by'],
created_by=data['created_by'],
modified_by=data['modified_by'],
created_at=data['created_at'],
modified_at=data['modified_at'],
is_deleted=data['is_deleted'],
)
user.set_password('1234')
db.session.add(user)
db.session.flush()
def sign_up(email, password, name, major):
origin_user = session.query(User).filter(User.email == email).first()
if origin_user:
abort(409, "this email is already in use")
else:
add_user = User(email=email,
password=generate_password_hash(password),
name=name,
major=major,
email_status=1)
session.add(add_user)
session.commit()
return {"message": "success"}, 201
def on_post(self, req, res):
# session = req.context['session']
user_req = req.context['data']
# user_req = args
if user_req:
user = User()
mongo_conn = initMongoDBConn(mongodb_collection)
account = mongo_conn['account'].find_one(
{'login': user_req['login'].lower()})
if account is not None:
status_code = (
falcon.HTTP_200,
404,
)
msg = 'Your login is in base, no need to register'
res.body = dumps({
'status': status_code[1],
'msg': msg,
})
return
user.login = user_req['data']['login']
user.email = user_req['data']['email']
user.password = hash_password(
user_req['data']['password']).decode('utf-8')
user.info = user_req['data']['info'] if 'info' in user_req else None
sid = uuid()
user.sid = sid
user.token = encrypt_token(sid).decode('utf-8')
# session.add(user)
id = self.__add_to_mongo(user_req['data'])
self.on_success(res, None, id)
'A way to serve static resources via Falcon'
# res.content_type = 'text/html'
# with open('index.html', 'r') as f:
# res.body = f.read()
else:
raise AssertionError(req.context['data'])
async def post(self):
try:
data = await self.request.json()
except:
raise exceptions.InvalidRequestException('No json send')
context = {
'db_session': self.request.db_session,
'ws_session': {'tz': data.get('user_timezone')},
'method': 'create',
'queue': self.request.app.queue
}
{%- if cookiecutter.closed_registration == 'y' %}
# ClOSED REGISTRATION
registration_token = data.get('registration_token')
if registration_token != \
config.get('registration_token'):
raise exceptions.InvalidRegistrationTokenException()
{%- endif %}
# INIT USER
user = User()
context['data'] = data
sane_data = await user.sanitize_data(context)
context['data'] = sane_data
await user.validate_and_save(context)
# SET SESSION
await set_session(user, self.request)
session = await get_session(self.request)
session['tz'] = data.get('user_timezone')
context['method'] = 'read'
context['user'] = user
context['ws_session'] = session
resp_data = {
'success': True,
'user': await user.serialize(context),
'token': session['csrf_token']
}
return web.json_response(resp_data)
'password': '******'
}, {
'name': 'admin',
'email': '*****@*****.**',
'password': '******',
'role': 'admin'
}, {
'name': 'disabled',
'email': '*****@*****.**',
'password': '******',
'enable': False
}
]
for user_data in users:
user = User()
context = {
'db_session': session,
'method': 'create',
'data': user_data
}
loop.run_until_complete(user.validate_and_save(context))
if user.name == 'test':
for index in range(40):
notification = Notification()
notification_data = {
'user_uid': user.get_uid(),
'message': 'Test {index}',
'target_url': '/profile',
'template_data': {
def client():
loop = asyncio.get_event_loop()
asyncio.set_event_loop(loop)
config = {
"env": "test",
"mongo_database_name": "webbase_test",
"redis_database": 13,
"mongo_host": "127.0.0.1",
"server_port": 1337,
"server_host": "localhost"
}
drop_database(config.get('mongo_database_name'),
config.get('redis_database'))
_, _, app = loop.run_until_complete(init(loop, config))
with DbSessionContext(config.get('mongo_database_name')) as session:
# INSERT DUMMY DATA
users = [{
'name': 'test',
'email': '*****@*****.**',
'email_validation_token': '123456',
'password': '******'
}, {
'name': 'to.disable',
'email': '*****@*****.**',
'email_validation_token': '1337',
'password': '******'
}, {
'name': 'admin',
'email': '*****@*****.**',
'password': '******',
'role': 'admin'
}, {
'name': 'disabled',
'email': '*****@*****.**',
'password': '******',
'enable': False
}]
notifications = [{
'user_uid': None,
'message': 'Test 1'
}, {
'user_uid': None,
'message': 'Test 2'
}, {
'user_uid': None,
'message': 'Test 3'
}, {
'user_uid': None,
'message': 'Test 4',
'seen': True
}]
for user_data in users:
user = User()
context = {
'db_session': session,
'method': 'create',
'data': user_data
}
loop.run_until_complete(user.validate_and_save(context))
context = {
'db_session': session,
'method': 'create',
'data': {
'user_uid': user.get_uid()
}
}
resetpasswordtoken = Resetpasswordtoken()
loop.run_until_complete(
resetpasswordtoken.validate_and_save(context))
for notification_data in notifications:
notification = Notification()
notification_data['user_uid'] = user.get_uid()
context = {
'db_session': session,
'method': 'create',
'data': notification_data
}
loop.run_until_complete(
notification.validate_and_save(context))
def login(self, email, password='******'):
self.post_json('/api/login', {
'email': email,
'password': password,
'token': self.__token__
})
with DbSessionContext(
self.config.get('mongo_database_name')) as session:
user = session.query(User)\
.filter(User.email == email).one()
return user
client = TestApp(app)
client.config = config
client.login = types.MethodType(login, client)
# NOTE Always do an /api/get_session to init the session correctly
data = {'user_timezone': 'Australia/Sydney'}
response = client.post_json('/api/get_session', data)
client.__token__ = response.json['token']
return client
def delete_user(user_id):
User.delete_user(user_id)
return jsonify({}), 200