def user_info():
if request.method == 'GET':
return jsonify(current_user.to_json())
if not request.is_json:
return _error('Request must be JSON type', 400)
form = request.get_json()
hashed = bcrypt.hashpw(form['password'].encode('utf-8'), bcrypt.gensalt())
user = User.query.filter(User.email == form['email']
or User.id == form['_id']).first()
print(user)
if request.method == 'PUT':
if user is not None:
return _error('An account with that email already exists', 400)
new_user = User(first_name=form.get('first_name'),
last_name=form.get('last_name'),
email=form['email'],
password=hashed)
db_session.add(new_user)
db_session.commit()
return jsonify(new_user.to_json())
elif request.method == 'POST':
if user is None:
return _error('Specified user not found', 400)
user.first_name = form.get('first_name')
user.last_name = form.get('last_name')
user.email = form.get('email')
if form.get('password') is not None:
user.password = hashed
db_session.add(user)
db_session.commit()
return jsonify(user.to_json())
return _error('Invalid request type.', 400)
def login():
""" POST only operation. check login form. Log user in """
if current_user.is_authenticated:
return response.make_success_resp(msg="You are already logged in")
form = LoginForm()
if form.validate_on_submit():
user, authenticated = User.authenticate(form.login.data,
form.password.data)
if user:
if authenticated:
login_user(user, remember=form.remember_me.data)
return response.make_data_resp(
data=current_user.to_json(),
msg="You have successfully logged in")
else:
return response.make_error_resp(
msg="Invalid username or password",
type="Wrong Authentication",
code=422)
else:
return response.make_error_resp(msg="Username does not exist",
type="Wrong Authentication",
code=422)
return response.make_form_error_resp(form=form)
def get(self, oauth_id=None):
"""
Gets current user information.
:param oauth_id:
:return: models/user/User plus owned_systems, secondary_systems
"""
if oauth_id is None:
oauth_id = current_user.oauth_id
if current_user.oauth_id != oauth_id:
# TODO: Check for admin status here.
abort(403)
data = current_user.to_json()
owned = OwnerModel.from_user(current_user)
try:
owned_data = owned.system_key.get().to_json()
except AttributeError:
data['owned_systems'] = []
else:
data['owned_systems'] = [owned_data, ]
secondary = Secondary.from_user(current_user)
secondary_data = [s.system_key.get().to_json() for s in secondary]
data['secondary_systems'] = secondary_data
return jsonify(data)
def update_state():
json_object = {"auth": False, "user": "******", "detectImg": []}
if current_user.is_authenticated:
# [print(img.image_filename) for img in current_user.det_img]
# [print(img.to_json()) for img in current_user.det_img]
json_object["auth"] = True
json_object["user"] = current_user.to_json()
detect_img_json = []
try:
json_files_path = [
path_to_json(img.image_filename)
for img in current_user.det_img
]
for json_path in json_files_path:
if isfile(json_path):
with open(json_path, ) as json_string:
detect_img_json.append(json.loads(json_string.read()))
else:
print(json_path, isfile(json_path))
except Exception as e:
print("ERR: ", e.__class__, "occurred.")
json_object["detectImg"] = json.loads(json.dumps(detect_img_json))
# print( 'updateState: ',str(json.dumps(json_object))[:500])
return jsonify(json_object)
def generate_resource_id():
auth_user = current_user.to_json()
userId = auth_user['id']
channelName = request.json['channelName']
# Get the base64 credential for making requests
credential = generate_base64_credential()
# Create connection object with basic URL
conn = http.client.HTTPSConnection("api.agora.io")
params = json.dumps({
"cname": channelName,
"uid": str(userId),
"clientRequest": {
"resourceExpiredHour": 24,
"scene": 0
}
})
# Create Header object
headers = {
"Content-type": "application/json;charset=utf-8",
"Authorization": "Basic " + credential
}
app_id = os.environ.get('AGORA_APP_ID')
resource_url_path = '/v1/apps/' + app_id + '/cloud_recording/acquire'
# Send request
conn.request("POST", resource_url_path, params, headers)
res = conn.getresponse()
data = res.read()
return data.decode("utf-8")
def show_movie_comments(id: str):
"""
Movie comments page.
:param id: str
:return:
"""
if request.method == 'POST':
comment = request.form['comment']
requests.post(
f'{MOVIE_SERVICE}/movies/{id}/comments',
json={
'movie_id': id,
'user': current_user.to_json(),
'text': comment,
'date': datetime.now().isoformat()
}
)
return redirect(url_for('show_movie', id=id))
r = requests.get(f'{MOVIE_SERVICE}/movie/{id}/comments')
if r.status_code == 200:
comments = r.json()['data']
else:
comments = []
context = {
'movie': _get_movie(id),
'comments': comments
}
return render_template('movie_comments.html', **context)
def login():
try:
idinfo = id_token.verify_oauth2_token(request.json["idToken"],
requests.Request(),
os.environ["GOOGLE_CLIENT_ID"])
if idinfo["iss"] not in [
"accounts.google.com", "https://accounts.google.com"
]:
raise ValueError("Incorrect issuer")
# google account id from decoded token
userid = idinfo["sub"]
# check if this user is already present in the database
user = User.query.filter_by(google_id=userid).first()
# if user doesn't exist, make a new user
if user is None or userid != request.json["id"]:
new_user = User(
email=request.json["email"],
username=request.json["name"],
google_id=request.json["id"],
google_image=request.json["photo"],
)
db.session.add(new_user)
db.session.commit()
user = new_user
login_user(user)
except ValueError:
return make_response(jsonify({"session": "Token not authorized"}), 400)
return make_response(jsonify(current_user.to_json()), 200)
def login(self):
"""
user login
/passport/
:return:
"""
form = LoginForm(request.form, csrf=False)
if form.validate_on_submit():
user = UserModel.query.filter_by(email=form.email.data).first()
if user is not None and user.verify_password(form.password.data):
try:
remember = False
if current_app.config.get("COOKIE_ENABLE"):
remember = True
current_app.logger.info(
"remember me(记住我)功能是否开启,{}".format(remember))
login_user(user, remember=remember)
user.fresh_session()
except WalleError as e:
return self.render_json(code=e.code,
data=Code.code_msg[e.code])
return self.render_json(data=current_user.to_json())
return self.render_json(code=Code.error_pwd, data=form.errors)
def get_members():
group_id = current_user.group_id
groups = User.query.filter(User.group_id == group_id).filter(User.id != current_user.id).all()
results = [i.to_json() for i in groups]
me = current_user.to_json()
me['real_name'] = '我'
results.insert(0, me)
return jsonify(results)
def sign():
access_id = request.args.get('access_id')
tonce = request.args.get('tonce')
now = time.time() * 1000
if access_id and tonce and now - 10000 < int(tonce) < now + 10000:
cu = current_user.to_json()
cu['token'] = serialize_data(cu)
return jsonify({'code': 200, 'message': 'OK', 'data': cu})
return jsonify({'code': 401, 'message': 'invalid request'})
def am_i_logged_in():
if request.method == 'GET' and getattr(current_user, 'id', None) is not None:
return jsonify(dict(
code=1,
user=current_user.to_json(),
temples=[t.light_json() for t in Temple.query.filter_by(active=True).all()]
))
else:
return jsonify(dict(code=0))
def get(self):
""" Get information of current user """
if Config.LOGIN_DISABLED:
return current_user.to_json()
user_json = fix_ids(current_user)
del user_json['password']
return {'user': user_json}
def call_user():
auth_user = current_user.to_json()
pusher_client.trigger(
'presence-online-channel', 'make-agora-call', {
'userToCall': request.json['user_to_call'],
'channelName': request.json['channel_name'],
'from': auth_user['id']
})
return jsonify({'message': 'call has been placed'})
def putUserEmail():
if not request.json or not 'email' in request.json:
return jsonify({'err': 'Request not Json or miss email'})
else:
current_user.email = request.json['email']
try:
current_user.save()
except Exception:
return jsonify({'err': 'Modify email error.'})
return jsonify({'status': 0, 'msg': 'Email has been modified.', 'user': current_user.to_json()})
def get(self):
if current_user.is_authenticated:
response = make_response(
jsonify(code=0,
message='get current_user success',
data={'user': current_user.to_json()}))
return response
else:
response = make_response(
jsonify(code=35, message='get current_user fail'))
return response
def decorated_function(*args, **kwargs):
if not current_user.registration_completed():
response = {
"status": "error",
"message":
"You did not finish your registration process. Please update your profile to continue!",
"data": current_user.to_json()
}
return response, 403
return f(*args, **kwargs)
def login():
id = request.form['id']
password = request.form['password']
user = User.query.filter_by(id=id).first()
if user and user.verify_password(password):
login_user(user)
LoginUser.append(user.id)
return jsonify({'code': 0, 'message': current_user.to_json()})
elif user:
return jsonify({'code': 2, 'message': '密码错误'})
else:
return jsonify({'code': 2, 'message': '账号不存在'})
def pusher_auth():
auth_user = current_user.to_json()
payload = pusher_client.authenticate(channel=request.form['channel_name'],
socket_id=request.form['socket_id'],
custom_data={
'user_id': auth_user['id'],
'user_info': {
'id': auth_user['id'],
'name': auth_user['username']
}
})
return jsonify(payload)
def logout():
"""
注销登录,解除会话 logout_user()
:return:
"""
current_app.logger.error("目前登录用户[%s]", current_user.to_json())
user = current_user
user.authenticated = False
auth_service.save_user(user)
logout_user()
session.pop('username', None)
return redirect(url_for("auth.login"))
def update_password():
if not request.is_json:
return _error('Request must be JSON type', 400)
form = request.get_json()
if not bcrypt.checkpw(form['old_password'].encode('utf-8'),
current_user.password):
return _error('Invalid credentials', 400)
p = bcrypt.hashpw(form['new_password'].encode('utf-8'), bcrypt.gensalt())
current_user.password = p
db_session.add(current_user)
db_session.commit()
return jsonify(current_user.to_json())
def put(self):
"""
Keys sent must be a subset or equal to the keys in model/user/User
:return: model/user/User
"""
data = request.get_json()
if data is None or not UserModel.valid_update_keys(data.keys()):
abort(400)
try:
current_user.update_from(data)
except ValueError as e:
abort(400, e.message)
return jsonify(current_user.to_json())
def login_user(self, login_info):
# Verify user is not already logged in
if current_user.is_authenticated:
print("User {} was already logged in".format(current_user.id))
self.response['data'] = current_user.to_json()
else:
user = User.query.filter_by(
email=login_info['email']).one_or_none()
if not user or not check_password_hash(user.password,
login_info['password']):
abort(400, "Please check login details and try again.")
login_user(user)
self.response['data'] = user.to_json()
def update_user_info():
"""更新当前用户信息
"""
q = parse_params(
request.json,
Rule('avatar'),
Rule('nickname'),
Rule('gender', allow = [UserGender.female, UserGender.male]),
Rule('bio')
)
User.query.filter_by(id = current_user.id).update(q)
db.session.commit()
return success({
'user': current_user.to_json()
})
def user_list():
if current_user.role == 'admin':
size = request.args.get("size", type=int, default=5)
page = request.args.get("page", type=int, default=1)
pagination = User.query.paginate(page=page,
per_page=size,
error_out=False)
return jsonify(sum=pagination.total,
total_page=pagination.pages,
current_page=pagination.page,
data=[w.to_json() for w in pagination.items])
else:
return jsonify(sum=1,
total_page=1,
current_page=1,
data=[current_user.to_json()])
def generate_agora_token():
auth_user = current_user.to_json()
appID = os.environ.get('AGORA_APP_ID')
appCertificate = os.environ.get('AGORA_APP_CERTIFICATE')
channelName = request.json['channelName']
userAccount = auth_user['username']
expireTimeInSeconds = 3600
currentTimestamp = int(time.time())
privilegeExpiredTs = currentTimestamp + expireTimeInSeconds
token = RtcTokenBuilder.buildTokenWithAccount(appID, appCertificate,
channelName, userAccount,
Role_Attendee,
privilegeExpiredTs)
return jsonify({'token': token, 'appID': appID})
def login(self):
"""
user login
/passport/
:return:
"""
form = LoginForm(request.form, csrf_enabled=False)
if form.validate_on_submit():
user = UserModel.query.filter_by(email=form.email.data).first()
if user is not None and user.verify_password(form.password.data):
login_user(user)
user.fresh_session()
return self.render_json(data=current_user.to_json())
return self.render_json(code=-1, data=form.errors)
def login(self):
"""
user login
/passport/
:return:
"""
form = LoginForm(request.form, csrf_enabled=False)
if form.validate_on_submit():
user = UserModel.query.filter_by(email=form.email.data).first()
if user is not None and user.verify_password(form.password.data):
login_user(user)
user.fresh_session()
return self.render_json(data=current_user.to_json())
return self.render_json(code=Code.error_pwd, data=form.errors)
def guest_login():
guest = User.query.filter_by(username="******").first()
if guest is None:
new_guest = User(
email="*****@*****.**",
username="******",
google_id="Not a Google account",
google_image="Not applicable",
)
db.session.add(new_guest)
db.session.commit()
guest = new_guest
login_user(guest)
return make_response(jsonify(current_user.to_json()), 200)
def login():
""" POST only operation. check login form. Log user in """
if current_user.is_authenticated:
return Response.make_success_resp(msg="You are already logged in")
form = LoginForm()
if form.validate_on_submit():
user, authenticated = User.authenticate(form.login.data, form.password.data)
if user :
if authenticated:
login_user(user, remember=form.remember_me.data)
return Response.make_data_resp(data=current_user.to_json(), msg="You have successfully logged in")
else:
return Response.make_error_resp(msg="Invalid username or password", type="Wrong Authentication", code=422)
else:
return Response.make_error_resp(msg="Username does not exist", type="Wrong Authentication", code=422)
return Response.make_form_error_resp(form=form)
def update_user():
'''
Update user's information at user's discretion\n
'''
# u_id = request.json.get('id', None)
f_name = request.json.get('fname', '')
# user = User.get_user_by_id(u_id)
if not current_user or not validate_request(request.json,
current_user.token):
return jsonify({'reason': 'invalid user or CSRF violation'}), 400
current_user.update_user(f_name)
ret = {
'reason': 'User successfully updated',
'result': current_user.to_json()
}
return jsonify(ret), 200
def login(self):
"""
user login
/passport/
:return:
"""
form = LoginForm(request.form, csrf=False)
if form.validate_on_submit():
user = UserModel.query.filter_by(email=form.email.data).first()
if user is not None and user.verify_password(form.password.data):
try:
login_user(user)
user.fresh_session()
except WalleError as e:
return self.render_json(code=e.code, data=Code.code_msg[e.code])
return self.render_json(data=current_user.to_json())
return self.render_json(code=Code.error_pwd, data=form.errors)
def myaccount():
user = current_user.to_json()
user['image_file'] = url_for('static',
filename='profile_pics/' + user['image_file'])
del user['password']
follow_list = []
for uid in user['follow']:
u = User.query.get_or_404(uid)
follow_list.append({uid: u.username})
user['follow'] = follow_list
black_list = []
for uid in user['black']:
u = User.query.get_or_404(uid)
black_list.append({uid: u.username})
user['black'] = black_list
data = {}
data['code'] = 1
data['user'] = user
return jsonify(data)
def login():
msg = ''
user_json = 'global'
if request.method == 'POST':
email = request.form.get('email')
password = request.form.get('password')
print(request.form)
user = User.query.filter_by(email=email).first()
if user:
if check_password_hash(user.password, password):
msg = 'Logged in successfully!'
login_user(user, remember=True)
user_json = current_user.to_json()
else:
msg = 'Incorrect password, try again.'
else:
msg = 'Email does not exist.'
print(msg)
response = jsonify({"success" : current_user.is_authenticated,
"user" : user_json,
"msg" : msg})
return response
def stop_recording():
auth_user = current_user.to_json()
userId = auth_user['id']
channelName = request.json['channelName']
token = request.json['token']
# Get the base64 credential for making requests
credential = generate_base64_credential()
conn = http.client.HTTPSConnection("api.agora.io")
params = json.dumps({
"cname": channelName,
"uid": str(userId),
"clientRequest": {
"token": token
}
})
# Create Header object
headers = {
"Content-type": "application/json;charset=utf-8",
"Authorization": "Basic " + credential
}
app_id = os.environ.get('AGORA_APP_ID')
resource_id = request.json['resourceId']
sid = request.json['sid']
resource_url_path = '/v1/apps/'+app_id + \
'/cloud_recording/resourceid/'+resource_id+'/sid/'+sid+'/mode/web/stop'
# Send request
conn.request("POST", resource_url_path, params, headers)
res = conn.getresponse()
data = res.read()
return data.decode("utf-8")
def verify_auth():
return Response.make_data_resp(data=current_user.to_json())
def get_my_info():
"""查询当前用户信息
"""
return success({
'user': current_user.to_json()
})
def get(self):
return current_user.to_json()
def update_user():
if request.is_json:
current_user.default_notebook = request.json.get('default_notebook')
db.session.commit()
return jsonify(current_user.to_json())
