def get_users_list():
page_num = int(request.args.get('page', 1))
page_size = int(request.args.get('size', 20))
dbms = request.args.get('dbms')
try:
check_alias(db_alias=dbms)
except DbmsAliasError:
return Result.gen_failed('404', 'dbms error')
name = request.args.get('name')
gender = request.args.get('gender')
cons = {'name': name, 'gender': gender}
kwargs = {}
for key, value in cons.items():
if value is not None and value != '':
kwargs[key] = value
_REDIS_KEY_ = f"{USERS_LIST}:{page_num}:{page_size}:{kwargs}"
data = RedisService().get_dict(dbms, _REDIS_KEY_)
if data is None or data == {}:
res = UserService().get_users(page_num=page_num,
page_size=page_size,
db_alias=dbms,
**kwargs)
_users = list()
total = UserService().count(db_alias=dbms, **kwargs)
for user in res:
_users.append(user.to_dict())
data = {'total': total, 'list': list(_users)}
RedisService().set_dict(dbms, _REDIS_KEY_, data)
return Result.gen_success(data)
def post(self, param=None):
if param is None:
self.write(json.dumps({"status": 0, "message": "Access Denied"}))
return
elif param == "login":
try:
data = tornado.escape.json_decode(self.request.body)
except:
self.write(
json.dumps({
"status": 0,
"message": "Invalid json format"
}))
return
us = UserService()
result = us.login(data)
self.write(json.dumps(result))
elif param == "signup":
try:
data = tornado.escape.json_decode(self.request.body)
except:
self.write(
json.dumps({
"status": 0,
"message": "Invalid json format"
}))
return
us = UserService()
result = us.register(data)
self.write(json.dumps(result))
elif param == "changepwd":
auth_header = self.request.headers.get('Authorization')
au = AuthUtil()
msg = au.checkToken(auth_header)
if not msg[0]:
self.write(msg[1])
try:
data = tornado.escape.json_decode(self.request.body)
except:
self.write(
json.dumps({
"status": 0,
"message": "Invalid json format"
}))
return
us = UserService()
result = us.change_password(data)
self.write(json.dumps(result))
elif param == "forgotpwd":
data = tornado.escape.json_decode(self.request.body)
print(data)
elif param == "schools":
data = tornado.escape.json_decode(self.request.body)
print(data)
def test_count(self):
print()
cnt = UserService().count(db_alias=DBMS.DBMS1)
print('DBMS1:', cnt)
cnt = UserService().count(db_alias=DBMS.DBMS2)
print('DBMS2:', cnt)
cnt = UserService().count_all()
print('all: ', cnt)
def registry(db_session):
email = request.json['email']
existing_user = UserService(db_session).get_user(email)
if existing_user and existing_user.active():
return handle_existing_active_user(existing_user)
existing_user = existing_user or UserService(db_session).create_user(email)
create_validation_code(db_session, email, existing_user)
return jsonify(convert_user(existing_user)), 201
def test_del(self):
# UserService().del_user_by_uid(49)
# user = UserService().get_user_by_uid(49)
# assert user is None
UserService().del_user_by_name('user10')
user = UserService().get_user_by_name('user10')
assert user is None
def test_login(self):
user1 = UserService().register('test1', 'password', 'male', 'asdf',
'asdfasdf', 'asdf', 'asdf', 'asdf',
'Beijing', 'asdf', 'asdfas', '123')
print(user1)
# time.sleep(5)
user = UserService().login('test1', 'password')
print(user)
assert user is not None
def user_query_by_name():
name = input("\n请输入查询的用户名: ")
user = UserService().get_user_by_name(name)
if user is None:
print("用户名不存在")
else:
UserService().pretty_users([user])
input("按回车键返回")
return None
def dashboard():
from config import DBMS
from service.user_service import UserService
from service.article_service import ArticleService
from service.read_service import ReadService
from service.popular_service import PopularService
dbms = request.args.get('dbms')
nums = {
'users':
UserService().count(db_alias=dbms),
'articles':
ArticleService().count(db_alias=dbms),
'reads':
ReadService().count(db_alias=dbms),
'populars':
PopularService().count(temporalGranularity='daily', db_alias=dbms)
}
charts = {'users': [], 'articles': [], 'reads': []}
for dbms in DBMS().get_all_dbms_by_region():
charts['users'].append({
'name': dbms,
'value': UserService().count(db_alias=dbms)
})
charts['articles'].append({
'name':
dbms,
'value':
ArticleService().count(db_alias=dbms)
})
charts['reads'].append({
'name': dbms,
'value': ReadService().count(db_alias=dbms)
})
data = {'nums': nums, 'charts': charts}
# if dbms == 'Beijing':
# data = {
# 'users': 12354,
# 'articles': 533366,
# 'reads': 23424,
# 'populars': 90372
# }
# else:
# data = {
# 'users': 63234,
# 'articles': 1284,
# 'reads': 724933,
# 'populars': 8422
# }
return Result.gen_success(data=data)
pass
def del_user():
username = input("请输入要删除的用户名： ")
user = UserService().get_user_by_name(username)
if user is None:
print("该用户不存在")
return None
UserService().pretty_users([user])
choice = input("是否删除该用户？（Y or N）： ")
if choice == 'Y' or choice == 'y' or choice == 'yes':
UserService().del_user_by_uid(user.uid)
print("删除成功")
return None
def test_update(self):
user = UserService().get_user_by_name('user4')
user = UserService().update_by_uid(user.uid,
gender='female',
email='ewrqwr')
assert user is not None
print(user)
user = UserService().update_by_name('user56',
gender='female',
email='awerasfsa')
assert user is not None
print(user)
def update_user_info():
forbid = ['id', 'name', 'region']
username = input("请输入要更新的用户名：")
user = UserService().get_user_by_name(username)
if user is None:
print("用户不存在")
return None
UserService().pretty_users([user])
update_date = input("请输入修改的内容(json格式)： ")
try:
con = json.loads(update_date)
return UserService().update_by_uid(user.uid, **con)
except json.JSONDecodeError:
print("输入不是json格式")
return None
def create_user_and_get_token(email):
os.environ['ONE_AUTH_ENV'] = 'test'
APP.config['TESTING'] = True
app = APP.test_client()
Mail(APP)
db_connection = get_db_session(APP.db_engine)
user_service = UserService(db_connection)
user_service.delete_user(email)
with patch.object(one_auth.ValidationCodeService,
'generate_validation_code', lambda: '123456'):
app.post('/one_auth/api/user',
data='{"email": "%s"}' % email,
content_type='application/json')
update_data = '{"email": "%s", "validation_code": "123456", "password": "******"}' % email
app.put('/one_auth/api/user',
data=update_data,
content_type='application/json')
response = app.get(
'/one_auth/api/access_tokens',
content_type='application/json',
headers={'Authorization': basic_auth(email, 'password1')})
return json.loads(response.data.decode('utf8'))['access_token']
def signin_user():
""" [서비스] 유저 로그인
Author: Mark Hasung Kim
Returns:
user_info: 유저 로그인 토큰 dict형식으로 반환해준다
"""
connection = None
try:
data = request.json
if 'username' not in data:
raise ApiException(400, INVALID_INPUT)
if 'password' not in data:
raise ApiException(400, INVALID_INPUT)
login_info = {
'username': data['username'],
'password': data['password']
}
connection = connect_db()
user_service = UserService()
user_info = user_service.signin_user(login_info, connection)
return user_info
except ApiException as e:
if connection:
connection.rollback()
raise e
finally:
if connection:
connection.close()
def add_user():
# TODO 使用选项模式来进行固定项的选择
name = input("请输入name: ")
pwd = input("请输入pwd: ")
gender = input("请输入gender: ")
email = input("请输入email: ")
phone = input("请输入phone: ")
dept = input("请输入dept: ")
grade = input("请输入grade: ")
language = input("请输入language: ")
region = input("请输入region: ")
role = input("请输入role: ")
preferTags = input("请输入preferTags: ")
obtainedCredits = (input("请输入obtainedCredits: "))
if region != "Beijing" and region != "Hong Kong":
print("输入的region错误，请重新输入！")
return
UserService().register(name, pwd, gender, email, phone, dept, grade,
language, region, role, preferTags,
obtainedCredits)
print("添加用户成功")
return
pass
def test_save_read(self, aid=None, uid=None):
aid = aid or ArticleService().get_articles_by_title('title4')[0].aid
uid = uid or UserService().get_user_by_name('user4').uid
read = self.readService.add_one(aid, uid, 1, 34, 2, 0, 'sdf', 1, 1)
assert read is not None
self.readService.pretty_reads([read])
return read
def test_register(self):
re1 = UserService().register('gahon', 'password', 'male', 'asdf',
'asdfasdf', 'asdf', 'asdf', 'asdf',
'Beijing', 'asdf', 'asdfas', '123')
assert re1
print(re1)
def test_user_list(self):
only = ['uid', 'name']
# users = UserService().users_list(only=only, db_alias=DBMS.DBMS1)
users = UserService().get_users(only=only, db_alias=DBMS.DBMS1)
# UserService().pretty_users(users)
pretty_models(users, only)
print('total: {}'.format(len(users)))
exclude = ['pwd']
# users = UserService().users_list(exclude=exclude, db_alias=DBMS.DBMS2)
users = UserService().get_users(exclude=exclude, db_alias=DBMS.DBMS2)
# UserService().pretty_users(users)
pretty_models(
users,
list(x for x in UserService.field_names if x not in exclude))
print('total: {}'.format(len(users)))
def user_repo_test():
user_service = UserService()
LOGGER.debug("=======USER REPO TEST=======")
username = "******"
password = "******"
first_name = "Muhammad"
last_name = "Aftab"
email = "*****@*****.**"
LOGGER.debug("adding a user")
user, msg = user_service.add_user(username, password, first_name, last_name, email)
LOGGER.debug(msg)
if user is not None:
LOGGER.debug("fetching the newly added user")
LOGGER.debug(user_repo.find_by_username(user.username))
LOGGER.debug("modifying user")
new_user = {"first_name": "Aftab",
"last_name": "Khan",
"email": "*****@*****.**",
"password": "******"}
updated_user = user_repo.update_user(username, new_user)
LOGGER.debug("the updated user is")
LOGGER.debug(updated_user)
LOGGER.debug("deleting user")
status = user_repo.delete_user(username)
LOGGER.debug(status)
def setUp(self):
self.app = APP.test_client()
UPLOAD_URL = '/images'
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
APP.config['UPLOAD_FOLDER'] = BASE_DIR + UPLOAD_URL
self.db_connection = get_db_session(APP.db_engine)
self.user_service = UserService(self.db_connection)
def test_get_by_uid_and_aid(self):
aid = ArticleService().get_articles_by_title('title')[0].aid
uid = UserService().get_user_by_name('user5').uid
read1 = self.test_save_read(aid, uid)
read = self.readService.get_by_uid_and_aid(uid=uid, aid=aid)
print(read)
assert read1.aid in read.item_frequencies(
'aid').keys() and read1.uid in read.item_frequencies('uid').keys()
def log_out():
email, access_token = parse_authorization_header()
if not authenticate_user_with_token(email, access_token):
return jsonify(message='Email or token is not correct'), 401
with DBConnector() as db_session:
UserService(db_session).delete_access_token(email)
return jsonify(message='success'), 200
def user_get(user_id):
"""
find a user info by id
:return: a json of user info
"""
user_service = UserService()
content = request.params
return user_service.find_one_user_by_id(session_id=content['session_id'])
def setUp(self):
os.environ['ONE_AUTH_ENV'] = 'test'
APP.config['TESTING'] = True
self.app = APP.test_client()
self.mail = Mail(APP)
self.db_connection = get_db_session(APP.db_engine)
self.user_service = UserService(self.db_connection)
self.validation_code_service = ValidationCodeService(self.db_connection)
def query_all(total, page_num=1, page_size=20, db_alias=None, **kwargs):
users = UserService().get_users(page_num,
page_size,
db_alias=db_alias,
**kwargs)
if len(users) == 0:
print("未查找到相关用户")
return
UserService().pretty_users(users)
show_next(page_num=page_num,
page_size=page_size,
db_alias=db_alias,
next_func=UserUI.query_all,
total=total,
**kwargs)
def test_read_twice(self):
aid = ArticleService().get_articles_by_title('title2')[0].aid
uid = UserService().get_user_by_name('user2').uid
read1 = self.readService.add_one(aid, uid, 1, 34, 2, 0, 'sdf', 0, 1)
ReadService().pretty_reads([read1])
read2 = self.readService.add_one(aid, uid, 1, 34, 2, 1, 'asdaff', 1, 1)
ReadService().pretty_reads([read2])
read1.reload()
assert read1.readSequence == read2.readSequence
def user_delete(user_id):
"""
delete a user info by id
:return: a status message
"""
user_service = UserService()
content = request.forms
return user_service.remove_user(session_id=content['session_id'],
user_id=content['user_id'])
def session_get(session_id):
"""
find a session by id
:return:
"""
user_service = UserService()
content = request.params
return user_service.find_one_session_by_id(
session_id=content['session_id'])
def authenticate_user_with_password(email, password):
if email is None or password is None:
return False
with DBConnector() as db_session:
user = UserService(db_session).get_user(email)
if user is not None and user.check_password(password):
g.current_user = user
return True
return False
def setUp(self):
os.environ['ONE_AUTH_ENV'] = 'test'
APP.config['TESTING'] = True
self.app = APP.test_client()
self.db_connection = get_db_session(APP.db_engine)
self.user_service = UserService(self.db_connection)
self.validation_code_service = ValidationCodeService(
self.db_connection)
self.create_user("*****@*****.**")
def authenticate_user_with_token(email, token):
if email is None or token is None:
return False
with DBConnector() as db_session:
user = UserService(db_session).get_user(email)
if user is not None and UserService.encode_access_token_for(
user) == token:
g.current_user = user
return True
return False
